﻿using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.Serialization.Formatters.Binary;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using CameraAccess;
using HalconDotNet;

namespace DimensionalMeasurement
{

    class PublicSet
    {
        /// <summary>
        /// 配置文件路径
        /// </summary>
        public static string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, $"Config\\{ProductNmae}");
        /// <summary>
        /// 参数设置对象
        /// </summary>
        public static MySet Myset;

        /// <summary>
        /// 相机参数设置
        /// </summary>
        public static CameraSet Cameraset;

        /// <summary>
        /// NG数显示设置
        /// </summary>
        public static DataShow Datashow;


        /// <summary>
        /// 测量线参数
        /// </summary>
        public static MeasureLine[] measureLines;
        /// <summary>
        /// 连接MySQL数据库
        /// </summary>
        public static string Connection;
        /// <summary>
        /// 负极极卷码
        /// </summary>
        public static string PolePieceIDN = "";
        /// <summary>
        /// 正极极卷码
        /// </summary>
        public static string PolePieceIDP = "";



        /// <summary>
        /// 字典存储检测项优先级
        /// </summary>
        public static Dictionary<int, string> DicDetectionItemPriority = new Dictionary<int, string>();
        /// <summary>
        /// 字典存储检测项优先级-王博要的
        /// </summary>
        public static Dictionary<int, string> DicDetectionItemPriority_W = new Dictionary<int, string>();
        /// <summary>
        /// 根据班次得到的时间，如果是夜班凌晨 日期为前一天
        /// </summary>
        public static DateTime TimeNow = new DateTime();

        #region 坐标矩阵
        /// <summary>
        /// 负极左上相机标定矩阵文件
        /// </summary>
        public static HTuple NLeftUpHomMat2D = new HTuple();
        /// <summary>
        /// 负极右上相机标定矩阵文件
        /// </summary>
        public static HTuple NRightUpHomMat2D = new HTuple();
        /// <summary>
        /// 负极左下相机标定矩阵文件
        /// </summary>
        public static HTuple NLeftDownHomMat2D = new HTuple();
        /// <summary>
        /// 负极右下相机标定矩阵文件
        /// </summary>
        public static HTuple NRightDownHomMat2D = new HTuple();

        /// <summary>
        /// 正极左上相机标定矩阵文件
        /// </summary>
        public static HTuple PLeftUpHomMat2D = new HTuple();
        /// <summary>
        /// 正极右上相机标定矩阵文件
        /// </summary>
        public static HTuple PRightUpHomMat2D = new HTuple();
        /// <summary>
        /// 正极左下相机标定矩阵文件
        /// </summary>
        public static HTuple PLeftDownHomMat2D = new HTuple();
        /// <summary>
        /// 正极左下相机标定矩阵文件
        /// </summary>
        public static HTuple PRightDownHomMat2D = new HTuple();
        #endregion


        /// <summary>
        /// 相机对象
        /// </summary>
        public static CameraBase NLeftUpcamera, NRightUpcamera, NLeftDowncamera, NRightDowncamera, PLeftUpcamera, PRightUpcamera, PLeftDowncamera, PRightDowncamera;
        public static bool bNLeftUpcamera, bNRightUpcamera, bNLeftDowncamera, bNRightDowncamera, bPLeftUpcamera, bPRightUpcamera, bPLeftDowncamera, bPRightDowncamera;
        /// <summary>
        /// 登录的用户
        /// </summary>
        public static UserInfo userInfo;
        /// <summary>
        /// 将设置参数序列化保存
        /// </summary>
        public static void SaveFile()
        {
            Stream sm = null;
            try
            {
                sm = File.Create($"{path}\\Config.bin");
                BinaryFormatter formatter = new BinaryFormatter();
                formatter.Serialize(sm, Myset);
                sm.Flush();

                Stream sm1 = File.Create($"{path}\\检测项优先级.bin");
                formatter = new BinaryFormatter();
                formatter.Serialize(sm1, DicDetectionItemPriority);
                sm1.Flush(); sm1.Close();

                Stream sm2 = File.Create($"{path}\\相机设置.bin");
                formatter = new BinaryFormatter();
                formatter.Serialize(sm2, Cameraset);
                sm2.Flush(); sm2.Close();
            }
            catch (Exception ex)
            {
            }
            finally
            {
                if (sm != null) sm.Close();
            }
        }

        /// <summary>
        /// 将设置参数序列化保存
        /// </summary>
        public static void SaveFile(string path)
        {
            Stream sm = null;
            try
            {
                sm = File.Create($"{path}\\Config.bin");
                BinaryFormatter formatter = new BinaryFormatter();
                formatter.Serialize(sm, Myset);
                sm.Flush();

                Stream sm1 = File.Create($"{path}\\检测项优先级.bin");
                formatter = new BinaryFormatter();
                formatter.Serialize(sm1, DicDetectionItemPriority);
                sm1.Flush(); sm1.Close();

                Stream sm2 = File.Create($"{path}\\相机设置.bin");
                formatter = new BinaryFormatter();
                formatter.Serialize(sm2, Cameraset);
                sm2.Flush(); sm2.Close();
            }
            catch (Exception ex)
            {
            }
            finally
            {
                if (sm != null) sm.Close();
            }
        }



        /// <summary>
        /// 将数据显示参数序列化保存
        /// </summary>
        public static void SaveDataShowFile()
        {
            Stream sm = null;
            try
            {
                sm = File.Create($"{path}\\数据显示设置.bin");
                BinaryFormatter formatter = new BinaryFormatter();
                formatter.Serialize(sm, Datashow);
                sm.Flush();


            }
            catch (Exception ex)
            {
            }
            finally
            {
                if (sm != null) sm.Close();
            }
        }

        /// <summary>
        /// 将数据显示参数序列化保存
        /// </summary>
        public static void SaveDataShowFile(string path)
        {
            Stream sm = null;
            try
            {
                sm = File.Create($"{path}\\数据显示设置.bin");
                BinaryFormatter formatter = new BinaryFormatter();
                formatter.Serialize(sm, Datashow);
                sm.Flush();
            }
            catch (Exception ex)
            {
            }
            finally
            {
                if (sm != null) sm.Close();
            }
        }



        /// <summary>
        /// 测量线参数序列化保存
        /// </summary>
        public static void SavaMeasureLine()
        {
            //序列化
            Stream SaveFileStream = File.Create($"{path}\\MeasureLine.bin");
            BinaryFormatter serializer = new BinaryFormatter();
            serializer.Serialize(SaveFileStream, PublicSet.measureLines);
            SaveFileStream.Close();
        }

        /// <summary>
        /// 测量线参数序列化保存
        /// </summary>
        public static void SavaMeasureLine(string path)
        {
            //序列化
            Stream SaveFileStream = File.Create($"{path}\\MeasureLine.bin");
            BinaryFormatter serializer = new BinaryFormatter();
            serializer.Serialize(SaveFileStream, PublicSet.measureLines);
            SaveFileStream.Close();
        }



        /// <summary>
        /// 读取设置参数与测量线参数(反序列化)
        /// </summary>
        public static void LoadSet()
        {
            #region 二进制反序列化
            if (!Directory.Exists(path))
            {
                Directory.CreateDirectory(path);
            }

            if (File.Exists($"{path}\\MeasureLine.bin"))
            { //测量线的反序列化
                BinaryFormatter binFormat = new BinaryFormatter();
                //序列化时对象会绑定程序集信息，程序集信息更改后反序列化不了，反序列化前改绑当前程序集信息
                // binFormat.Binder = new AllowAllAssemblyVersionsDeserializationBinder();
                Stream open = File.OpenRead($"{path}\\MeasureLine.bin");
                MeasureLine[] measureLines1 = (MeasureLine[])binFormat.Deserialize(open);
                open.Close();
                if (measureLines1.Length != 80)
                {
                    measureLines = new MeasureLine[80];
                    for (int i = 0; i < measureLines.Length; ++i)
                    {
                        measureLines[i] = new MeasureLine();
                    }
                    for (int i = 0; i < measureLines1.Length; ++i)
                    {
                        measureLines[i] = measureLines1[i];
                    }
                }
                else
                {
                    measureLines = measureLines1;
                }
            }
            else
            {
                measureLines = new MeasureLine[80];
                for (int i = 0; i < measureLines.Length; ++i)
                {
                    measureLines[i] = new MeasureLine();
                }
            }

            if (File.Exists($"{path}\\Config.bin"))
            {
                try
                {
                    //参数设置的反序列化
                    BinaryFormatter formatter = new BinaryFormatter();
                    //序列化时对象会绑定程序集信息，程序集信息更改后反序列化不了，反序列化前改绑当前程序集信息
                    formatter.Binder = new AllowAllAssemblyVersionsDeserializationBinder();
                    //FileStream open = new FileStream($"{path}\\Config.bin", FileMode.Open);
                    Stream open = File.OpenRead($"{path}\\Config.bin");
                    Myset = (MySet)formatter.Deserialize(open);
                    open.Close();
                }
                catch (Exception w)
                {

                }
            }
            else
            {
                Myset = new MySet();

            }

            if (File.Exists($"{path}\\检测项优先级.bin"))
            {
                try
                {
                    //参数设置的反序列化
                    BinaryFormatter formatter = new BinaryFormatter();
                    //序列化时对象会绑定程序集信息，程序集信息更改后反序列化不了，反序列化前改绑当前程序集信息
                    formatter.Binder = new AllowAllAssemblyVersionsDeserializationBinder();
                    //FileStream open = new FileStream($"{path}\\Config.bin", FileMode.Open);
                    Stream open = File.OpenRead($"{path}\\检测项优先级.bin");
                    DicDetectionItemPriority = (Dictionary<int, string>)formatter.Deserialize(open);
                    open.Close();
                }
                catch (Exception w)
                {

                }
            }

            if (File.Exists($"{path}\\相机设置.bin"))
            {
                try
                {
                    //参数设置的反序列化
                    BinaryFormatter formatter = new BinaryFormatter();
                    //序列化时对象会绑定程序集信息，程序集信息更改后反序列化不了，反序列化前改绑当前程序集信息
                    formatter.Binder = new AllowAllAssemblyVersionsDeserializationBinder();
                    //FileStream open = new FileStream($"{path}\\Config.bin", FileMode.Open);
                    Stream open = File.OpenRead($"{path}\\相机设置.bin");
                    Cameraset = (CameraSet)formatter.Deserialize(open);
                    open.Close();
                }
                catch (Exception w)
                {

                }
            }
            else
            {
                Cameraset = new CameraSet();

            }

            if (File.Exists($"{path}\\数据显示设置.bin"))
            {
                try
                {
                    //参数设置的反序列化
                    BinaryFormatter formatter = new BinaryFormatter();
                    //序列化时对象会绑定程序集信息，程序集信息更改后反序列化不了，反序列化前改绑当前程序集信息
                    formatter.Binder = new AllowAllAssemblyVersionsDeserializationBinder();
                    //FileStream open = new FileStream($"{path}\\Config.bin", FileMode.Open);
                    Stream open = File.OpenRead($"{path}\\数据显示设置.bin");
                    Datashow = (DataShow)formatter.Deserialize(open);
                    open.Close();
                }
                catch (Exception w)
                {

                }
            }
            else
            {
                Datashow = new DataShow();

            }
            SaveFile();
            #endregion
        }

        /// <summary>
        /// 读取标定矩阵
        /// </summary>
        public static void GetTuple()
        {
            #region 读取正负极转换矩阵
            int count = 0;
            string HomMat2Dpath;
            if (Myset.DetectMode == "3相机正负单测")
            {
                if (Myset.NegativeSwitch)
                {
                    //负极矩阵
                    HomMat2Dpath = $"{path}\\矩阵文件\\1负极左上相机.tup";
                    if (File.Exists(HomMat2Dpath))
                    {
                        HOperatorSet.ReadTuple(HomMat2Dpath, out NLeftUpHomMat2D);
                        ++count;
                    }
                    HomMat2Dpath = $"{path}\\矩阵文件\\2负极右上相机.tup";
                    if (File.Exists(HomMat2Dpath))
                    {
                        HOperatorSet.ReadTuple(HomMat2Dpath, out NRightUpHomMat2D);
                        ++count;
                    }
                    HomMat2Dpath = $"{path}\\矩阵文件\\3负极左下相机.tup";
                    if (File.Exists(HomMat2Dpath))
                    {
                        HOperatorSet.ReadTuple(HomMat2Dpath, out NLeftDownHomMat2D);
                        ++count;
                    }
                    //HomMat2Dpath = $"{path}\\矩阵文件\\4负极右下相机.tup";
                    //if (File.Exists(HomMat2Dpath))
                    //{
                    //    HOperatorSet.ReadTuple(HomMat2Dpath, out NRightDownHomMat2D);
                    //    ++count;
                    //}
                    if (count != 3) MessageBox.Show("缺少矩阵文件");
                }
                else
                {
                    //正极矩阵
                    HomMat2Dpath = $"{path}\\矩阵文件\\5正极左上相机.tup";
                    if (File.Exists(HomMat2Dpath))
                    {
                        HOperatorSet.ReadTuple(HomMat2Dpath, out PLeftUpHomMat2D);
                        ++count;
                    }
                    HomMat2Dpath = $"{path}\\矩阵文件\\6正极右上相机.tup";
                    if (File.Exists(HomMat2Dpath))
                    {
                        HOperatorSet.ReadTuple(HomMat2Dpath, out PRightUpHomMat2D);
                        ++count;
                    }
                    HomMat2Dpath = $"{path}\\矩阵文件\\7正极左下相机.tup";
                    if (File.Exists(HomMat2Dpath))
                    {
                        HOperatorSet.ReadTuple(HomMat2Dpath, out PLeftDownHomMat2D);
                        ++count;
                    }
                    //HomMat2Dpath = $"{path}\\矩阵文件\\8正极右下相机.tup";
                    //if (File.Exists(HomMat2Dpath))
                    //{
                    //    HOperatorSet.ReadTuple(HomMat2Dpath, out PRightDownHomMat2D);
                    //    ++count;
                    //}
                    if (count != 3) MessageBox.Show("缺少矩阵文件");
                }
                return;
            }
            if (Myset.DetectMode == "2相机正负双测")
            {
                //负极矩阵
                HomMat2Dpath = $"{path}\\矩阵文件\\1负极左上相机.tup";
                if (File.Exists(HomMat2Dpath))
                {
                    HOperatorSet.ReadTuple(HomMat2Dpath, out NLeftUpHomMat2D);
                    ++count;
                }
                HomMat2Dpath = $"{path}\\矩阵文件\\3负极左下相机.tup";
                if (File.Exists(HomMat2Dpath))
                {
                    HOperatorSet.ReadTuple(HomMat2Dpath, out NLeftDownHomMat2D);
                    ++count;
                }
                //正极矩阵
                HomMat2Dpath = $"{path}\\矩阵文件\\6正极右上相机.tup";
                if (File.Exists(HomMat2Dpath))
                {
                    HOperatorSet.ReadTuple(HomMat2Dpath, out PRightUpHomMat2D);
                    ++count;
                }
                HomMat2Dpath = $"{path}\\矩阵文件\\8正极右下相机.tup";
                if (File.Exists(HomMat2Dpath))
                {
                    HOperatorSet.ReadTuple(HomMat2Dpath, out PRightDownHomMat2D);
                    ++count;
                }
                if (count != 4) MessageBox.Show("缺少矩阵文件");
                return;
            }

            if (Myset.DetectMode == "4相机正负单测")
            {
                if (PublicSet.Myset.NegativeSwitch)
                {
                    //负极矩阵
                    HomMat2Dpath = $"{path}\\矩阵文件\\1负极左上相机.tup";
                    if (File.Exists(HomMat2Dpath))
                    {
                        HOperatorSet.ReadTuple(HomMat2Dpath, out NLeftUpHomMat2D);
                        ++count;
                    }
                    HomMat2Dpath = $"{path}\\矩阵文件\\2负极右上相机.tup";
                    if (File.Exists(HomMat2Dpath))
                    {
                        HOperatorSet.ReadTuple(HomMat2Dpath, out NRightUpHomMat2D);
                        ++count;
                    }
                    HomMat2Dpath = $"{path}\\矩阵文件\\3负极左下相机.tup";
                    if (File.Exists(HomMat2Dpath))
                    {
                        HOperatorSet.ReadTuple(HomMat2Dpath, out NLeftDownHomMat2D);
                        ++count;
                    }
                    HomMat2Dpath = $"{path}\\矩阵文件\\4负极右下相机.tup";
                    if (File.Exists(HomMat2Dpath))
                    {
                        HOperatorSet.ReadTuple(HomMat2Dpath, out NRightDownHomMat2D);
                        ++count;
                    }
                    if (count != 4) MessageBox.Show("缺少矩阵文件"); return;
                }
                else
                {
                    //正极矩阵
                    HomMat2Dpath = $"{path}\\矩阵文件\\5正极左上相机.tup";
                    if (File.Exists(HomMat2Dpath))
                    {
                        HOperatorSet.ReadTuple(HomMat2Dpath, out PLeftUpHomMat2D);
                        ++count;
                    }
                    HomMat2Dpath = $"{path}\\矩阵文件\\6正极右上相机.tup";
                    if (File.Exists(HomMat2Dpath))
                    {
                        HOperatorSet.ReadTuple(HomMat2Dpath, out PRightUpHomMat2D);
                        ++count;
                    }
                    HomMat2Dpath = $"{path}\\矩阵文件\\7正极左下相机.tup";
                    if (File.Exists(HomMat2Dpath))
                    {
                        HOperatorSet.ReadTuple(HomMat2Dpath, out PLeftDownHomMat2D);
                        ++count;
                    }
                    HomMat2Dpath = $"{path}\\矩阵文件\\8正极右下相机.tup";
                    if (File.Exists(HomMat2Dpath))
                    {
                        HOperatorSet.ReadTuple(HomMat2Dpath, out PRightDownHomMat2D);
                        ++count;
                    }
                    if (count != 4) MessageBox.Show("缺少矩阵文件"); return;
                }
            }
            else
            {
                //负极矩阵
                HomMat2Dpath = $"{path}\\矩阵文件\\1负极左上相机.tup";
                if (File.Exists(HomMat2Dpath))
                {
                    HOperatorSet.ReadTuple(HomMat2Dpath, out NLeftUpHomMat2D);
                    ++count;
                }
                HomMat2Dpath = $"{path}\\矩阵文件\\2负极右上相机.tup";
                if (File.Exists(HomMat2Dpath))
                {
                    HOperatorSet.ReadTuple(HomMat2Dpath, out NRightUpHomMat2D);
                    ++count;
                }
                HomMat2Dpath = $"{path}\\矩阵文件\\3负极左下相机.tup";
                if (File.Exists(HomMat2Dpath))
                {
                    HOperatorSet.ReadTuple(HomMat2Dpath, out NLeftDownHomMat2D);
                    ++count;
                }
                HomMat2Dpath = $"{path}\\矩阵文件\\4负极右下相机.tup";
                if (File.Exists(HomMat2Dpath))
                {
                    HOperatorSet.ReadTuple(HomMat2Dpath, out NRightDownHomMat2D);
                    ++count;
                }

                //正极矩阵
                HomMat2Dpath = $"{path}\\矩阵文件\\5正极左上相机.tup";
                if (File.Exists(HomMat2Dpath))
                {
                    HOperatorSet.ReadTuple(HomMat2Dpath, out PLeftUpHomMat2D);
                    ++count;
                }
                HomMat2Dpath = $"{path}\\矩阵文件\\6正极右上相机.tup";
                if (File.Exists(HomMat2Dpath))
                {
                    HOperatorSet.ReadTuple(HomMat2Dpath, out PRightUpHomMat2D);
                    ++count;
                }
                HomMat2Dpath = $"{path}\\矩阵文件\\7正极左下相机.tup";
                if (File.Exists(HomMat2Dpath))
                {
                    HOperatorSet.ReadTuple(HomMat2Dpath, out PLeftDownHomMat2D);
                    ++count;
                }
                HomMat2Dpath = $"{path}\\矩阵文件\\8正极右下相机.tup";
                if (File.Exists(HomMat2Dpath))
                {
                    HOperatorSet.ReadTuple(HomMat2Dpath, out PRightDownHomMat2D);
                    ++count;
                }
                if (count != 8) MessageBox.Show("缺少矩阵文件");
            }




            #endregion
        }

        /// <summary>
        /// 保存矩阵
        /// </summary>
        public static void SavaTuple()
        {
            Directory.CreateDirectory($"{path}\\矩阵文件");
            if (Myset.DetectMode == "3相机正负单测")
            {
                if (Myset.NegativeSwitch)
                {
                    HOperatorSet.WriteTuple(PublicSet.NLeftUpHomMat2D, $"{path}\\矩阵文件\\1负极左上相机.tup");
                    HOperatorSet.WriteTuple(PublicSet.NRightUpHomMat2D, $"{path}\\矩阵文件\\2负极右上相机.tup");
                    HOperatorSet.WriteTuple(PublicSet.NLeftDownHomMat2D, $"{path}\\矩阵文件\\3负极左下相机.tup");
                    //  HOperatorSet.WriteTuple(PublicSet.NRightDownHomMat2D, $"{path}\\矩阵文件\\4负极右下相机.tup");
                }
                else
                {
                    HOperatorSet.WriteTuple(PublicSet.PLeftUpHomMat2D, $"{path}\\矩阵文件\\5正极左上相机.tup");
                    HOperatorSet.WriteTuple(PublicSet.PRightUpHomMat2D, $"{path}\\矩阵文件\\6正极右上相机.tup");
                    HOperatorSet.WriteTuple(PublicSet.PLeftDownHomMat2D, $"{path}\\矩阵文件\\7正极左下相机.tup");
                    //   HOperatorSet.WriteTuple(PublicSet.PRightDownHomMat2D, $"{path}\\矩阵文件\\8正极右下相机.tup");
                }
                return;
            }
            if (Myset.DetectMode == "2相机正负双测")
            {

                HOperatorSet.WriteTuple(PublicSet.NLeftUpHomMat2D, $"{path}\\矩阵文件\\1负极左上相机.tup");
                HOperatorSet.WriteTuple(PublicSet.NLeftDownHomMat2D, $"{path}\\矩阵文件\\3负极左下相机.tup");
                HOperatorSet.WriteTuple(PublicSet.PRightUpHomMat2D, $"{path}\\矩阵文件\\6正极右上相机.tup");
                HOperatorSet.WriteTuple(PublicSet.PRightDownHomMat2D, $"{path}\\矩阵文件\\8正极右下相机.tup");

                return;
            }
            HOperatorSet.WriteTuple(PublicSet.NLeftUpHomMat2D, $"{path}\\矩阵文件\\1负极左上相机.tup");
            HOperatorSet.WriteTuple(PublicSet.NRightUpHomMat2D, $"{path}\\矩阵文件\\2负极右上相机.tup");
            HOperatorSet.WriteTuple(PublicSet.NLeftDownHomMat2D, $"{path}\\矩阵文件\\3负极左下相机.tup");
            HOperatorSet.WriteTuple(PublicSet.NRightDownHomMat2D, $"{path}\\矩阵文件\\4负极右下相机.tup");

            HOperatorSet.WriteTuple(PublicSet.PLeftUpHomMat2D, $"{path}\\矩阵文件\\5正极左上相机.tup");
            HOperatorSet.WriteTuple(PublicSet.PRightUpHomMat2D, $"{path}\\矩阵文件\\6正极右上相机.tup");
            HOperatorSet.WriteTuple(PublicSet.PLeftDownHomMat2D, $"{path}\\矩阵文件\\7正极左下相机.tup");
            HOperatorSet.WriteTuple(PublicSet.PRightDownHomMat2D, $"{path}\\矩阵文件\\8正极右下相机.tup");

        }
        /// <summary>
        /// 保存矩阵
        /// </summary>
        public static void SavaTuple(string path)
        {
            Directory.CreateDirectory($"{path}\\矩阵文件");
            if (Myset.DetectMode == "3相机正负单测")
            {
                if (Myset.NegativeSwitch)
                {
                    HOperatorSet.WriteTuple(PublicSet.NLeftUpHomMat2D, $"{path}\\矩阵文件\\1负极左上相机.tup");
                    HOperatorSet.WriteTuple(PublicSet.NRightUpHomMat2D, $"{path}\\矩阵文件\\2负极右上相机.tup");
                    HOperatorSet.WriteTuple(PublicSet.NLeftDownHomMat2D, $"{path}\\矩阵文件\\3负极左下相机.tup");
                    //  HOperatorSet.WriteTuple(PublicSet.NRightDownHomMat2D, $"{path}\\矩阵文件\\4负极右下相机.tup");
                }
                else
                {
                    HOperatorSet.WriteTuple(PublicSet.PLeftUpHomMat2D, $"{path}\\矩阵文件\\5正极左上相机.tup");
                    HOperatorSet.WriteTuple(PublicSet.PRightUpHomMat2D, $"{path}\\矩阵文件\\6正极右上相机.tup");
                    HOperatorSet.WriteTuple(PublicSet.PLeftDownHomMat2D, $"{path}\\矩阵文件\\7正极左下相机.tup");
                    //   HOperatorSet.WriteTuple(PublicSet.PRightDownHomMat2D, $"{path}\\矩阵文件\\8正极右下相机.tup");
                }
                return;
            }
            if (Myset.DetectMode == "2相机正负双测")
            {

                HOperatorSet.WriteTuple(PublicSet.NLeftUpHomMat2D, $"{path}\\矩阵文件\\1负极左上相机.tup");
                HOperatorSet.WriteTuple(PublicSet.NLeftDownHomMat2D, $"{path}\\矩阵文件\\3负极左下相机.tup");
                HOperatorSet.WriteTuple(PublicSet.PRightUpHomMat2D, $"{path}\\矩阵文件\\6正极右上相机.tup");
                HOperatorSet.WriteTuple(PublicSet.PRightDownHomMat2D, $"{path}\\矩阵文件\\8正极右下相机.tup");

                return;
            }
            HOperatorSet.WriteTuple(PublicSet.NLeftUpHomMat2D, $"{path}\\矩阵文件\\1负极左上相机.tup");
            HOperatorSet.WriteTuple(PublicSet.NRightUpHomMat2D, $"{path}\\矩阵文件\\2负极右上相机.tup");
            HOperatorSet.WriteTuple(PublicSet.NLeftDownHomMat2D, $"{path}\\矩阵文件\\3负极左下相机.tup");
            HOperatorSet.WriteTuple(PublicSet.NRightDownHomMat2D, $"{path}\\矩阵文件\\4负极右下相机.tup");

            HOperatorSet.WriteTuple(PublicSet.PLeftUpHomMat2D, $"{path}\\矩阵文件\\5正极左上相机.tup");
            HOperatorSet.WriteTuple(PublicSet.PRightUpHomMat2D, $"{path}\\矩阵文件\\6正极右上相机.tup");
            HOperatorSet.WriteTuple(PublicSet.PLeftDownHomMat2D, $"{path}\\矩阵文件\\7正极左下相机.tup");
            HOperatorSet.WriteTuple(PublicSet.PRightDownHomMat2D, $"{path}\\矩阵文件\\8正极右下相机.tup");

        }

        static CameraBase GetCamera(string s)
        {
            switch (s)
            {
                case "海康": return new CameraHikvision();
                case "大华": return new CameraDahua();
                case "巴斯勒": return new CameraBasler();
                case "大恒": return new CameraDaheng();
                default: return new CameraBasler();

            }
        }
        /// <summary>
        /// 所有相机集合
        /// </summary>
        public static string[] HikvisionList = null, DahuaList = null, DahengList = null, BaslerList = null, AllList = null;
        public static void InitCamera()
        {
            try
            {
                HikvisionList = CameraHikvision.DeviceListAcq();
            }
            catch (Exception)
            {
            }
            try
            {
                DahuaList = CameraDahua.DeviceListAcq();
            }
            catch (Exception)
            {
            }
            try
            {
                BaslerList = CameraBasler.DeviceListAcq();
            }
            catch (Exception)
            {
            }
            try
            {
                DahengList = CameraDaheng.DeviceListAcq();
            }
            catch (Exception)
            {
            }
            AllList = new string[(HikvisionList == null ? 0 : HikvisionList.Length) + (DahuaList == null ? 0 : DahuaList.Length) + (DahengList == null ? 0 : DahengList.Length) + (BaslerList == null ? 0 : BaslerList.Length)];
            // 合并所有数组
            int index = 0;
            // 依次复制每个数组的元素
            if (HikvisionList != null)
            {
                foreach (var item in HikvisionList)
                {
                    AllList[index++] = item + ">" + "海康";
                }
            }
            if (DahuaList != null)
            {
                foreach (var item in DahuaList)
                {
                    AllList[index++] = item + ">" + "大华";
                }
            }
            if (DahengList != null)
            {
                foreach (var item in DahengList)
                {
                    AllList[index++] = item + ">" + "大恒";
                }
            }
            if (BaslerList != null)
            {
                foreach (var item in BaslerList)
                {
                    AllList[index++] = item + ">" + "巴斯勒";
                }
            }
            try
            {
                if (Myset.DetectMode == "8相机正负双测")
                {
                    string[] strs = Cameraset.NLeftUpCamera.Split('>');
                    if (strs.Length == 2)
                    {
                        NLeftUpcamera = GetCamera(strs[1]);
                        if (NLeftUpcamera.Open(strs[0]))
                        {
                            bNLeftUpcamera = true;
                            NLeftUpcamera.ReadImageEvent += FormMain.Instance.NLeftUpGrabImage;
                            NLeftUpcamera.ConnectLossEvent += FormMain.Instance.CameraConnectLossNLeftUp;
                            NLeftUpcamera.SetTriggerMode(TriggerMode.On);
                            NLeftUpcamera.SetTriggerSource(TriggerSource.Line1);
                            NLeftUpcamera.StartGrab();
                            Tool.LogForm(Cameraset.NLeftUpCamreraName + "连接成功");
                        }
                        else
                        {
                            bNLeftUpcamera = false;
                            Tool.LogForm(Cameraset.NLeftUpCamreraName + "连接失败");
                            ToastNotification.Show(Cameraset.NLeftUpCamreraName + "连接失败");
                        }
                    }

                    strs = Cameraset.NRightUpCamera.Split('>');
                    if (strs.Length == 2)
                    {
                        NRightUpcamera = GetCamera(strs[1]);
                        if (NRightUpcamera.Open(strs[0]))
                        {
                            bNRightUpcamera = true;
                            NRightUpcamera.ReadImageEvent += FormMain.Instance.NRightUpGrabImage;
                            NRightUpcamera.ConnectLossEvent += FormMain.Instance.CameraConnectLossNRightUp;
                            NRightUpcamera.SetTriggerMode(TriggerMode.On);
                            NRightUpcamera.SetTriggerSource(TriggerSource.Line1);
                            NRightUpcamera.StartGrab();
                            Tool.LogForm(Cameraset.NRightUpCamreraName + "连接成功");
                        }
                        else
                        {
                            bNRightUpcamera = false;
                            Tool.LogForm(Cameraset.NRightUpCamreraName + "连接失败");
                            ToastNotification.Show(Cameraset.NRightUpCamreraName + "连接失败");
                        }
                    }

                    strs = Cameraset.NLeftDownCamera.Split('>');
                    if (strs.Length == 2)
                    {
                        NLeftDowncamera = GetCamera(strs[1]);
                        if (NLeftDowncamera.Open(strs[0]))
                        {
                            bNLeftDowncamera = true;
                            NLeftDowncamera.ReadImageEvent += FormMain.Instance.NLeftDownGrabImage;
                            NLeftDowncamera.ConnectLossEvent += FormMain.Instance.CameraConnectLossNLeftDown;
                            NLeftDowncamera.SetTriggerMode(TriggerMode.On);
                            NLeftDowncamera.SetTriggerSource(TriggerSource.Line1);
                            NLeftDowncamera.StartGrab();
                            Tool.LogForm(Cameraset.NLeftDownCamreraName + "连接成功");
                        }
                        else
                        {
                            bNLeftDowncamera = false;
                            Tool.LogForm(Cameraset.NLeftDownCamreraName + "连接失败");
                            ToastNotification.Show(Cameraset.NLeftDownCamreraName + "连接失败");
                        }
                    }
                    strs = Cameraset.NRightDownCamera.Split('>');
                    if (strs.Length == 2)
                    {
                        NRightDowncamera = GetCamera(strs[1]);
                        if (NRightDowncamera.Open(strs[0]))
                        {
                            bNRightDowncamera = true;
                            NRightDowncamera.ReadImageEvent += FormMain.Instance.NRightDownGrabImage;
                            NRightDowncamera.ConnectLossEvent += FormMain.Instance.CameraConnectLossNRightDown;
                            NRightDowncamera.SetTriggerMode(TriggerMode.On);
                            NRightDowncamera.SetTriggerSource(TriggerSource.Line1);
                            NRightDowncamera.StartGrab();
                            Tool.LogForm(Cameraset.NRightDownCamreraName + "连接成功");
                        }
                        else
                        {
                            bNRightDowncamera = false;
                            Tool.LogForm(Cameraset.NRightDownCamreraName + "连接失败");
                            ToastNotification.Show(Cameraset.NRightDownCamreraName + "连接失败");
                        }
                    }

                    strs = Cameraset.PLeftUpCamera.Split('>');
                    if (strs.Length == 2)
                    {
                        PLeftUpcamera = GetCamera(strs[1]);
                        if (PLeftUpcamera.Open(strs[0]))
                        {
                            bPLeftUpcamera = true;
                            PLeftUpcamera.ReadImageEvent += FormMain.Instance.PLeftUpGrabImage;
                            PLeftUpcamera.ConnectLossEvent += FormMain.Instance.CameraConnectLossPLeftUp;
                            PLeftUpcamera.SetTriggerMode(TriggerMode.On);
                            PLeftUpcamera.StartGrab();
                            Tool.LogForm(Cameraset.PLeftUpCamreraName + "连接成功");
                        }
                        else
                        {
                            bPLeftUpcamera = false;
                            Tool.LogForm(Cameraset.PLeftUpCamreraName + "连接失败");
                            ToastNotification.Show(Cameraset.PLeftUpCamreraName + "连接失败");
                        }
                    }
                    strs = Cameraset.PRightUpCamera.Split('>');
                    if (strs.Length == 2)
                    {
                        PRightUpcamera = GetCamera(strs[1]);
                        if (PRightUpcamera.Open(strs[0]))
                        {
                            bPRightUpcamera = true;
                            PRightUpcamera.ReadImageEvent += FormMain.Instance.PRightUpGrabImage;
                            PRightUpcamera.ConnectLossEvent += FormMain.Instance.CameraConnectLossPRightUp;
                            PRightUpcamera.SetTriggerMode(TriggerMode.On);
                            PRightUpcamera.StartGrab();
                            Tool.LogForm(Cameraset.PRightUpCamreraName + "连接成功");
                        }
                        else
                        {
                            bPRightUpcamera = false;
                            Tool.LogForm(Cameraset.PRightUpCamreraName + "连接失败");
                            ToastNotification.Show(Cameraset.PRightUpCamreraName + "连接失败");
                        }
                    }
                    strs = Cameraset.PLeftDownCamera.Split('>');
                    if (strs.Length == 2)
                    {
                        PLeftDowncamera = GetCamera(strs[1]);
                        if (PLeftDowncamera.Open(strs[0]))
                        {
                            bPLeftDowncamera = true;
                            PLeftDowncamera.ReadImageEvent += FormMain.Instance.PLeftDownGrabImage;
                            PLeftDowncamera.ConnectLossEvent += FormMain.Instance.CameraConnectLossPLeftDown;
                            PLeftDowncamera.SetTriggerMode(TriggerMode.On);
                            PLeftDowncamera.StartGrab();
                            Tool.LogForm(Cameraset.PLeftDownCamreraName + "连接成功");
                        }
                        else
                        {
                            bPLeftDowncamera = false;
                            Tool.LogForm(Cameraset.PLeftDownCamreraName + "连接失败");
                            ToastNotification.Show(Cameraset.PLeftDownCamreraName + "连接失败");
                        }
                    }
                    strs = Cameraset.PRightDownCamera.Split('>');
                    if (strs.Length == 2)
                    {
                        PRightDowncamera = GetCamera(strs[1]);
                        if (PRightDowncamera.Open(strs[0]))
                        {
                            bPRightDowncamera = true;
                            PRightDowncamera.ReadImageEvent += FormMain.Instance.PRightDownGrabImage;
                            PRightDowncamera.ConnectLossEvent += FormMain.Instance.CameraConnectLossPRightDown;
                            PRightDowncamera.SetTriggerMode(TriggerMode.On);
                            PRightDowncamera.StartGrab();
                            Tool.LogForm(Cameraset.PRightDownCamreraName + "连接成功");
                        }
                        else
                        {
                            bPRightDowncamera = false;
                            Tool.LogForm(Cameraset.PRightDownCamreraName + "连接失败");
                            ToastNotification.Show(Cameraset.PRightDownCamreraName + "连接失败");
                        }
                    }
                    if (bNLeftUpcamera && bNRightUpcamera && bNLeftDowncamera && bNRightDowncamera && bPLeftUpcamera && bPRightUpcamera && bPLeftDowncamera && bPRightDowncamera) ToastNotification.Show("所有相机连接成功");
                }

                if (Myset.DetectMode == "3相机正负单测" || Myset.DetectMode == "4相机正负单测")
                {
                    if (Myset.NegativeSwitch)
                    {
                        string[] strs = Cameraset.NLeftUpCamera.Split('>');
                        if (strs.Length == 2)
                        {
                            NLeftUpcamera = GetCamera(strs[1]);
                            if (NLeftUpcamera.Open(strs[0]))
                            {
                                bNLeftUpcamera = true;
                                NLeftUpcamera.ReadImageEvent += FormMain.Instance.NLeftUpGrabImage;
                                NLeftUpcamera.ConnectLossEvent += FormMain.Instance.CameraConnectLossNLeftUp;
                                NLeftUpcamera.SetTriggerMode(TriggerMode.On);
                                NLeftUpcamera.StartGrab();
                                Tool.LogForm(Cameraset.NLeftUpCamreraName + "连接成功");
                            }
                            else
                            {
                                bNLeftUpcamera = false;
                                Tool.LogForm(Cameraset.NLeftUpCamreraName + "连接失败");
                                ToastNotification.Show(Cameraset.NLeftUpCamreraName + "连接失败");
                            }
                        }

                        strs = Cameraset.NRightUpCamera.Split('>');
                        if (strs.Length == 2)
                        {
                            NRightUpcamera = GetCamera(strs[1]);
                            if (NRightUpcamera.Open(strs[0]))
                            {
                                bNRightUpcamera = true;
                                NRightUpcamera.ReadImageEvent += FormMain.Instance.NRightUpGrabImage;
                                NRightUpcamera.ConnectLossEvent += FormMain.Instance.CameraConnectLossNRightUp;
                                NRightUpcamera.SetTriggerMode(TriggerMode.On);
                                NRightUpcamera.StartGrab();
                                Tool.LogForm(Cameraset.NRightUpCamreraName + "连接成功");
                            }
                            else
                            {
                                bNRightUpcamera = false;
                                Tool.LogForm(Cameraset.NRightUpCamreraName + "连接失败");
                                ToastNotification.Show(Cameraset.NRightUpCamreraName + "连接失败");
                            }
                        }

                        strs = Cameraset.NLeftDownCamera.Split('>');
                        if (strs.Length == 2)
                        {
                            NLeftDowncamera = GetCamera(strs[1]);
                            if (NLeftDowncamera.Open(strs[0]))
                            {
                                bNLeftDowncamera = true;
                                NLeftDowncamera.ReadImageEvent += FormMain.Instance.NLeftDownGrabImage;
                                NLeftDowncamera.ConnectLossEvent += FormMain.Instance.CameraConnectLossNLeftDown;
                                NLeftDowncamera.SetTriggerMode(TriggerMode.On);
                                NLeftDowncamera.StartGrab();
                                Tool.LogForm(Cameraset.NLeftDownCamreraName + "连接成功");
                            }
                            else
                            {
                                bNLeftDowncamera = false;
                                Tool.LogForm(Cameraset.NLeftDownCamreraName + "连接失败");
                                ToastNotification.Show(Cameraset.NLeftDownCamreraName + "连接失败");
                            }
                        }
                        if (Myset.DetectMode == "4相机正负单测")
                        {
                            strs = Cameraset.NRightDownCamera.Split('>');
                            if (strs.Length == 2)
                            {
                                NRightDowncamera = GetCamera(strs[1]);
                                if (NRightDowncamera.Open(strs[0]))
                                {
                                    bNRightDowncamera = true;
                                    NRightDowncamera.ReadImageEvent += FormMain.Instance.NRightDownGrabImage;
                                    NRightDowncamera.ConnectLossEvent += FormMain.Instance.CameraConnectLossNRightDown;
                                    NRightDowncamera.SetTriggerMode(TriggerMode.On);
                                    //NRightDowncamera.SetTriggerSource(TriggerSource.Line1);
                                    NRightDowncamera.StartGrab();
                                    Tool.LogForm(Cameraset.NRightDownCamreraName + "连接成功");
                                }
                                else
                                {
                                    bNRightDowncamera = false;
                                    Tool.LogForm(Cameraset.NRightDownCamreraName + "连接失败");
                                    ToastNotification.Show(Cameraset.NRightDownCamreraName + "连接失败");
                                }
                            }
                        }
                    }
                    else
                    {
                        string[] strs = Cameraset.PLeftUpCamera.Split('>');
                        if (strs.Length == 2)
                        {
                            PLeftUpcamera = GetCamera(strs[1]);
                            if (PLeftUpcamera.Open(strs[0]))
                            {
                                bPLeftUpcamera = true;
                                PLeftUpcamera.ReadImageEvent += FormMain.Instance.PLeftUpGrabImage;
                                PLeftUpcamera.ConnectLossEvent += FormMain.Instance.CameraConnectLossPLeftUp;
                                PLeftUpcamera.SetTriggerMode(TriggerMode.On);
                                PLeftUpcamera.StartGrab();
                                Tool.LogForm(Cameraset.PLeftUpCamreraName + "连接成功");
                            }
                            else
                            {
                                bPLeftUpcamera = false;
                                Tool.LogForm(Cameraset.PLeftUpCamreraName + "连接失败");
                                ToastNotification.Show(Cameraset.PLeftUpCamreraName + "连接失败");
                            }
                        }
                        strs = Cameraset.PRightUpCamera.Split('>');
                        if (strs.Length == 2)
                        {
                            PRightUpcamera = GetCamera(strs[1]);
                            if (PRightUpcamera.Open(strs[0]))
                            {
                                bPRightUpcamera = true;
                                PRightUpcamera.ReadImageEvent += FormMain.Instance.PRightUpGrabImage;
                                PRightUpcamera.ConnectLossEvent += FormMain.Instance.CameraConnectLossPRightUp;
                                PRightUpcamera.SetTriggerMode(TriggerMode.On);
                                PRightUpcamera.StartGrab();
                                Tool.LogForm(Cameraset.PRightUpCamreraName + "连接成功");
                            }
                            else
                            {
                                bPRightUpcamera = false;
                                Tool.LogForm(Cameraset.PRightUpCamreraName + "连接失败");
                                ToastNotification.Show(Cameraset.PRightUpCamreraName + "连接失败");
                            }
                        }

                        strs = Cameraset.PLeftDownCamera.Split('>');
                        if (strs.Length == 2)
                        {
                            PLeftDowncamera = GetCamera(strs[1]);
                            if (PLeftDowncamera.Open(strs[0]))
                            {
                                bPLeftDowncamera = true;
                                PLeftDowncamera.ReadImageEvent += FormMain.Instance.PLeftDownGrabImage;
                                PLeftDowncamera.ConnectLossEvent += FormMain.Instance.CameraConnectLossPLeftDown;
                                PLeftDowncamera.SetTriggerMode(TriggerMode.On);
                                PLeftDowncamera.StartGrab();
                                Tool.LogForm(Cameraset.PLeftDownCamreraName + "连接成功");
                            }
                            else
                            {
                                bPLeftDowncamera = false;
                                Tool.LogForm(Cameraset.PLeftDownCamreraName + "连接失败");
                                ToastNotification.Show(Cameraset.PLeftDownCamreraName + "连接失败");
                            }
                        }
                        if (Myset.DetectMode == "4相机正负单测")
                        {
                            strs = Cameraset.PRightDownCamera.Split('>');
                            if (strs.Length == 2)
                            {
                                PRightDowncamera = GetCamera(strs[1]);
                                if (PRightDowncamera.Open(strs[0]))
                                {
                                    bPRightDowncamera = true;
                                    PRightDowncamera.ReadImageEvent += FormMain.Instance.PRightDownGrabImage;
                                    PRightDowncamera.ConnectLossEvent += FormMain.Instance.CameraConnectLossPRightDown;
                                    PRightDowncamera.SetTriggerMode(TriggerMode.On);
                                    PRightDowncamera.StartGrab();
                                    Tool.LogForm(Cameraset.PRightDownCamreraName + "连接成功");
                                }
                                else
                                {
                                    bPRightDowncamera = false;
                                    Tool.LogForm(Cameraset.PRightDownCamreraName + "连接失败");
                                    ToastNotification.Show(Cameraset.PRightDownCamreraName + "连接失败");
                                }
                            }
                        }
                    }
                }

                if (Myset.DetectMode == "2相机正负双测")
                {
                    string[] strs = Cameraset.NLeftUpCamera.Split('>');
                    if (strs.Length == 2)
                    {
                        NLeftUpcamera = GetCamera(strs[1]);
                        if (NLeftUpcamera.Open(strs[0]))
                        {
                            bNLeftUpcamera = true;
                            NLeftUpcamera.ReadImageEvent += FormMain.Instance.NLeftUpGrabImage;
                            NLeftUpcamera.ConnectLossEvent += FormMain.Instance.CameraConnectLossNLeftUp;
                            NLeftUpcamera.SetTriggerMode(TriggerMode.On);
                            NLeftUpcamera.StartGrab();
                            Tool.LogForm(Cameraset.NLeftUpCamreraName + "连接成功");
                        }
                        else
                        {
                            bNLeftUpcamera = false;
                            Tool.LogForm(Cameraset.NLeftUpCamreraName + "连接失败");
                            ToastNotification.Show(Cameraset.NLeftUpCamreraName + "连接失败");
                        }
                    }
                    strs = Cameraset.NLeftDownCamera.Split('>');
                    if (strs.Length == 2)
                    {
                        NLeftDowncamera = GetCamera(strs[1]);
                        if (NLeftDowncamera.Open(strs[0]))
                        {
                            bNLeftDowncamera = true;
                            NLeftDowncamera.ReadImageEvent += FormMain.Instance.NLeftDownGrabImage;
                            NLeftDowncamera.ConnectLossEvent += FormMain.Instance.CameraConnectLossNLeftDown;
                            NLeftDowncamera.SetTriggerMode(TriggerMode.On);
                            NLeftDowncamera.StartGrab();
                            Tool.LogForm(Cameraset.NLeftDownCamreraName + "连接成功");
                        }
                        else
                        {
                            bNLeftDowncamera = false;
                            Tool.LogForm(Cameraset.NLeftDownCamreraName + "连接失败");
                            ToastNotification.Show(Cameraset.NLeftDownCamreraName + "连接失败");
                        }
                    }
                    strs = Cameraset.PRightUpCamera.Split('>');
                    if (strs.Length == 2)
                    {
                        PRightUpcamera = GetCamera(strs[1]);
                        if (PRightUpcamera.Open(strs[0]))
                        {
                            bPRightUpcamera = true;
                            PRightUpcamera.ReadImageEvent += FormMain.Instance.PRightUpGrabImage;
                            PRightUpcamera.ConnectLossEvent += FormMain.Instance.CameraConnectLossPRightUp;
                            PRightUpcamera.SetTriggerMode(TriggerMode.On);
                            PRightUpcamera.StartGrab();
                            Tool.LogForm(Cameraset.PRightUpCamreraName + "连接成功");
                        }
                        else
                        {
                            bPRightUpcamera = false;
                            Tool.LogForm(Cameraset.PRightUpCamreraName + "连接失败");
                            ToastNotification.Show(Cameraset.PRightUpCamreraName + "连接失败");
                        }
                    }
                    strs = Cameraset.PRightDownCamera.Split('>');
                    if (strs.Length == 2)
                    {
                        PRightDowncamera = GetCamera(strs[1]);
                        if (PRightDowncamera.Open(strs[0]))
                        {
                            bPRightDowncamera = true;
                            PRightDowncamera.ReadImageEvent += FormMain.Instance.PRightDownGrabImage;
                            PRightDowncamera.ConnectLossEvent += FormMain.Instance.CameraConnectLossPRightDown;
                            PRightDowncamera.SetTriggerMode(TriggerMode.On);
                            PRightDowncamera.StartGrab();
                            Tool.LogForm(Cameraset.PRightDownCamreraName + "连接成功");
                        }
                        else
                        {
                            bPRightDowncamera = false;
                            Tool.LogForm(Cameraset.PRightDownCamreraName + "连接失败");
                            ToastNotification.Show(Cameraset.PRightDownCamreraName + "连接失败");
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Tool.LogForm(ex);
            }

        }

        private static string productNmae;
        /// <summary>
        /// 产品型号
        /// </summary>
        public static string ProductNmae
        {
            get
            {
                return productNmae = INIOperate.Read("System", "ProductNmae", "默认", $"Config\\System.ini");
            }
            set
            {
                if (value != productNmae)
                {
                    Tool.LogParameterUpdate("用户：" + PublicSet.userInfo.name + " 对产品型号" + "进行更改！旧值为：" + ProductNmae + "   当前值为：" + value);
                    INIOperate.Write("System", "ProductNmae", value, $"Config\\System.ini");
                    INIOperate.Write("System", "ProductNmae", value, $"Config备份\\Config\\System.ini");
                    productNmae = value;
                }
            }
        }

    }



    [Serializable]
    class CameraSet
    {
        #region 相机设置       
        /// <summary>
        /// 负极左上相机标识
        /// </summary>
        public string NLeftUpCamera;
        /// <summary>
        /// 负极左上相机像素比列
        /// </summary>
        public double NLeftUpCamreraPixelRatio;
        /// <summary>
        /// 负极左上相机自定义命名
        /// </summary>
        public string NLeftUpCamreraName = "负左上";

        /// <summary>
        /// 负极右上相机标识
        /// </summary>
        public string NRightUpCamera;
        /// <summary>
        /// 负极右上相机像素比列
        /// </summary>
        public double NRightUpCamreraPixelRatio;
        /// <summary>
        /// 负极右上相机自定义命名
        /// </summary>
        public string NRightUpCamreraName = "负右上";

        /// <summary>
        /// 负极左下相机标识
        /// </summary>
        public string NLeftDownCamera;
        /// <summary>
        /// 负极左下相机像素比列
        /// </summary>
        public double NLeftDownCamreraPixelRatio;
        /// <summary>
        /// 负极左下相机自定义命名
        /// </summary>
        public string NLeftDownCamreraName = "负左下";

        /// <summary>
        /// 负极右下相机标识
        /// </summary>
        public string NRightDownCamera;
        /// <summary>
        /// 负极右下相机像素比列
        /// </summary>
        public double NRightDownCamreraPixelRatio;
        /// <summary>
        /// 负极右下相机自定义命名
        /// </summary>
        public string NRightDownCamreraName = "负右下";


        /// <summary>
        /// 正极左上相机标识
        /// </summary>
        public string PLeftUpCamera;
        /// <summary>
        /// 正极左上相机像素比列
        /// </summary>
        public double PLeftUpCamreraPixelRatio;
        /// <summary>
        /// 正极左上相机自定义命名
        /// </summary>
        public string PLeftUpCamreraName = "正左上";

        /// <summary>
        /// 正极右上相机标识
        /// </summary>
        public string PRightUpCamera;
        /// <summary>
        /// 正极右上相机像素比列
        /// </summary>
        public double PRightUpCamreraPixelRatio;
        /// <summary>
        /// 正极右上相机自定义命名
        /// </summary>
        public string PRightUpCamreraName = "正右上";

        /// <summary>
        /// 正极左下相机标识
        /// </summary>
        public string PLeftDownCamera;
        /// <summary>
        /// 正极左下相机像素比列
        /// </summary>
        public double PLeftDownCamreraPixelRatio;
        /// <summary>
        /// 正极左下相机自定义命名
        /// </summary>
        public string PLeftDownCamreraName = "正左下";

        /// <summary>
        /// 正极右下相机标识
        /// </summary>
        public string PRightDownCamera;
        /// <summary>
        /// 正极右下相机像素比列
        /// </summary>
        public double PRightDownCamreraPixelRatio;
        /// <summary>
        /// 正极右下相机自定义命名
        /// </summary>
        public string PRightDownCamreraName = "正右下";

        #endregion

        #region 正负极相机基准线坐标

        /// <summary>
        /// 负极左上相机基准行坐标
        /// </summary>
        public double NLeftUpStandardRow;
        /// <summary>
        /// 负极左上相机基准列坐标
        /// </summary>
        public double NLeftUpStandardColumn;

        /// <summary>
        /// 负极右上相机基准行坐标
        /// </summary>
        public double NRightUpStandardRow;
        /// <summary>
        /// 负极右上相机基准列坐标
        /// </summary>
        public double NRightUpStandardColumn;

        /// <summary>
        /// 负极左下相机基准行坐标
        /// </summary>
        public double NLeftDownStandardRow;
        /// <summary>
        /// 负极左下相机基准列坐标
        /// </summary>
        public double NLeftDownStandardColumn;

        /// <summary>
        /// 负极右下相机基准行坐标
        /// </summary>
        public double NRightDownStandardRow;
        /// <summary>
        /// 负极右下相机基准列坐标
        /// </summary>
        public double NRightDownStandardColumn;


        /// <summary>
        /// 正极左上相机基准行坐标
        /// </summary>
        public double PLeftUpStandardRow;
        /// <summary>
        /// 正极左上相机基准列坐标
        /// </summary>
        public double PLeftUpStandardColumn;

        /// <summary>
        /// 正极右上相机基准行坐标
        /// </summary>
        public double PRightUpStandardRow;
        /// <summary>
        /// 正极右上相机基准列坐标
        /// </summary>
        public double PRightUpStandardColumn;

        /// <summary>
        /// 正极左下相机基准行坐标
        /// </summary>
        public double PLeftDownStandardRow;
        /// <summary>
        /// 正极左下相机基准列坐标
        /// </summary>
        public double PLeftDownStandardColumn;

        /// <summary>
        /// 正极右下相机基准行坐标
        /// </summary>
        public double PRightDownStandardRow;
        /// <summary>
        /// 正极右下相机基准列坐标
        /// </summary>
        public double PRightDownStandardColumn;


        #endregion

        /// <summary>
        /// 线体编号
        /// </summary>
        public string LineID = "01";
        /// <summary>
        /// 设备编号
        /// </summary>
        public string MachineID = "01";

        #region 正负极注册基准设置
        /// <summary>
        /// 负极注册基准
        /// </summary>
        public bool NRegisterStandard;


        /// <summary>
        /// 负极注册基准-X基准位置
        /// </summary>
        public double XStandard;
        /// <summary>
        /// 负极注册基准-Y基准位置
        /// </summary>
        public double YStandard;
        /// <summary>
        /// 负极注册基准-Z基准位置
        /// </summary>
        public double ZStandard;

        /// <summary>
        /// 正极注册基准
        /// </summary>
        public bool PRegisterStandard;
        /// <summary>
        /// 正极X方向基准值
        /// </summary>
        public double PXStandard;
        /// <summary>
        /// 正极Y方向基准值
        /// </summary>
        public double PYStandard;
        /// <summary>
        /// 正极z方向基准值
        /// </summary>
        public double PZStandard;

        #region mark点基准
        /// <summary>
        /// 负极左上markX基准点
        /// </summary>
        public double NLeftUpMarkXStandard;
        /// <summary>
        /// 负极左上markY基准点
        /// </summary>
        public double NLeftUpMarkYStandard;
        /// <summary>
        /// 负极右上markX基准点
        /// </summary>
        public double NRightUpMarkXStandard;
        /// <summary>
        /// 负极右上markY基准点
        /// </summary>
        public double NRightUpMarkYStandard;
        /// <summary>
        /// 负极左下markX基准点
        /// </summary>
        public double NLeftDownMarkXStandard;
        /// <summary>
        /// 负极左下markY基准点
        /// </summary>
        public double NLeftDownMarkYStandard;
        /// <summary>
        /// 负极右下markX基准点
        /// </summary>
        public double NRightDownMarkXStandard;
        /// <summary>
        /// 负极右下markY基准点
        /// </summary>
        public double NRightDownMarkYStandard;

        /// <summary>
        /// 正极左上markX基准点
        /// </summary>
        public double PLeftUpMarkXStandard;
        /// <summary>
        /// 正极左上markY基准点
        /// </summary>
        public double PLeftUpMarkYStandard;
        /// <summary>
        /// 正极右上markX基准点
        /// </summary>
        public double PRightUpMarkXStandard;
        /// <summary>
        /// 正极右上markY基准点
        /// </summary>
        public double PRightUpMarkYStandard;
        /// <summary>
        /// 正极左下markX基准点
        /// </summary>
        public double PLeftDownMarkXStandard;
        /// <summary>
        /// 正极左下markY基准点
        /// </summary>
        public double PLeftDownMarkYStandard;
        /// <summary>
        /// 正极右下markX基准点
        /// </summary>
        public double PRightDownMarkXStandard;
        /// <summary>
        /// 正极右下markY基准点
        /// </summary>
        public double PRightDownMarkYStandard;
        #endregion


        #endregion


        #region 工艺补偿值

        #region 负极工艺

        /// <summary>
        /// 负极极片头宽补偿值
        /// </summary>
        public double NJPHeadWidthCompensate;

        /// <summary>
        /// 负极极片尾宽补偿值
        /// </summary>
        public double NJPTailWidthCompensate;

        /// <summary>
        /// 负极极片头长补偿值
        /// </summary>
        public double NJPHeadLengthCompensate;

        /// <summary>
        /// 负极极片尾长补偿值
        /// </summary>
        public double NJPTailLengthCompensate;

        /// <summary>
        /// 负极左肩宽补偿值
        /// </summary>
        public double NJELeftShoulderCompensate;

        /// <summary>
        /// 负极右肩宽补偿值
        /// </summary>
        public double NJERightShoulderCompensate;

        /// <summary>
        /// 负极极耳宽补偿值
        /// </summary>
        public double NJEWidthCompensate;

        /// <summary>
        /// 负极极耳高补偿值
        /// </summary>
        public double NJEHeightCompensate;


        /// <summary>
        /// 负极带料高补偿值
        /// </summary>
        public double NDLHeightCompensate;

        /// <summary>
        /// 负极极片总宽补偿值
        /// </summary>
        public double NJPTotalWidthCompensate;

        /// <summary>
        /// 负极涂布高补偿值
        /// </summary>
        public double NJPCoatingCompensate;

        /// <summary>
        /// 负极对角线补偿值
        /// </summary>
        public double NDiagonalCompensate;

        /// <summary>
        /// 负极左上角度补偿值
        /// </summary>
        public double NLeftUpAngleCompensate;

        /// <summary>
        /// 负极右上角度补偿值
        /// </summary>
        public double NRightUpAngleCompensate;

        /// <summary>
        /// 负极左下角度补偿值
        /// </summary>
        public double NLeftDownAngleCompensate;

        /// <summary>
        /// 负极右下角度补偿值
        /// </summary>
        public double NRightDownAngleCompensate;




        #endregion

        #region 负极V角工艺

        #region 负极左上右上V角

        /// <summary>
        /// 负极左上V角度补偿值
        /// </summary>
        public double NLeftUpVAngleCompensate;

        /// <summary>
        /// 负极左上V宽度补偿值
        /// </summary>
        public double NLeftUpVWidthCompensate;

        /// <summary>
        /// 负极左上V深度补偿值
        /// </summary>
        public double NLeftUpVDepthCompensate;

        /// <summary>
        /// 负极右上V角度补偿值
        /// </summary>
        public double NRightUpVAngleCompensate;

        /// <summary>
        /// 负极右上V宽度补偿值
        /// </summary>
        public double NRightUpVWidthCompensate;

        /// <summary>
        /// 负极右上V深度补偿值
        /// </summary>
        public double NRightUpVDepthCompensate;

        #endregion

        #region 负极左下右下V角

        /// <summary>
        /// 负极左下V角度补偿值
        /// </summary>
        public double NLeftDownVAngleCompensate;

        /// <summary>
        /// 负极左下V宽度补偿值
        /// </summary>
        public double NLeftDownVWidthCompensate;

        /// <summary>
        /// 负极左下V深度补偿值
        /// </summary>
        public double NLeftDownVDepthCompensate;

        /// <summary>
        /// 负极右下V角度补偿值
        /// </summary>
        public double NRightDownVAngleCompensate;

        /// <summary>
        /// 负极右下V宽度补偿值
        /// </summary>
        public double NRightDownVWidthCompensate;

        /// <summary>
        /// 负极右下V深度补偿值
        /// </summary>
        public double NRightDownVDepthCompensate;


        #endregion

        #endregion

        #region 正极工艺

        /// <summary>
        /// 正极极片头宽补偿值
        /// </summary>
        public double PJPHeadWidthCompensate;

        /// <summary>
        /// 正极极片尾宽补偿值
        /// </summary>
        public double PJPTailWidthCompensate;

        /// <summary>
        /// 正极极片头长补偿值
        /// </summary>
        public double PJPHeadLengthCompensate;

        /// <summary>
        /// 正极极片尾长补偿值
        /// </summary>
        public double PJPTailLengthCompensate;

        /// <summary>
        /// 正极左肩宽补偿值
        /// </summary>
        public double PJELeftShoulderCompensate;

        /// <summary>
        /// 正极右肩宽补偿值
        /// </summary>
        public double PJERightShoulderCompensate;

        /// <summary>
        /// 正极极耳宽补偿值
        /// </summary>
        public double PJEWidthCompensate;

        /// <summary>
        /// 正极极耳高补偿值
        /// </summary>
        public double PJEHeightCompensate;

        /// <summary>
        /// 正极陶瓷高补偿值
        /// </summary>
        public double PCeramicHeightCompensate;

        /// <summary>
        /// 正极极片总宽补偿值
        /// </summary>
        public double PJPTotalWidthCompensate;

        /// <summary>
        /// 正极涂布高补偿值
        /// </summary>
        public double PJPCoatingCompensate;

        /// <summary>
        /// 正极对角线补偿值
        /// </summary>
        public double PDiagonalCompensate;

        /// <summary>
        /// 正极左上角度补偿值
        /// </summary>
        public double PLeftUpAngleCompensate;

        /// <summary>
        /// 正极右上角度补偿值
        /// </summary>
        public double PRightUpAngleCompensate;

        /// <summary>
        /// 正极左下角度补偿值
        /// </summary>
        public double PLeftDownAngleCompensate;

        /// <summary>
        /// 正极右下角度补偿值
        /// </summary>
        public double PRightDownAngleCompensate;

        #endregion

        #region 正极V角工艺
        #region 正极左上右上V角

        /// <summary>
        /// 正极左上V角度补偿值
        /// </summary>
        public double PLeftUpVAngleCompensate;

        /// <summary>
        /// 正极左上V宽度补偿值
        /// </summary>
        public double PLeftUpVWidthCompensate;

        /// <summary>
        /// 正极左上V深度补偿值
        /// </summary>
        public double PLeftUpVDepthCompensate;

        /// <summary>
        /// 正极右上V角度补偿值
        /// </summary>
        public double PRightUpVAngleCompensate;

        /// <summary>
        /// 正极右上V宽度补偿值
        /// </summary>
        public double PRightUpVWidthCompensate;

        /// <summary>
        /// 正极右上V深度补偿值
        /// </summary>
        public double PRightUpVDepthCompensate;


        #endregion
        #region 正极左下右下V角

        /// <summary>
        /// 正极左下V角度补偿值
        /// </summary>
        public double PLeftDownVAngleCompensate;

        /// <summary>
        /// 正极左下V宽度补偿值
        /// </summary>
        public double PLeftDownVWidthCompensate;

        /// <summary>
        /// 正极左下V深度补偿值
        /// </summary>
        public double PLeftDownVDepthCompensate;

        /// <summary>
        /// 正极右下V角度补偿值
        /// </summary>
        public double PRightDownVAngleCompensate;

        /// <summary>
        /// 正极右下V宽度补偿值
        /// </summary>
        public double PRightDownVWidthCompensate;

        /// <summary>
        /// 正极右下V深度补偿值
        /// </summary>
        public double PRightDownVDepthCompensate;


        #endregion

        #endregion


        #endregion

        public CameraSet() { }

    }

    [Serializable]
    class DataShow
    {
        public DataShow() { }
        #region 负极每班次NG数

        /// <summary>
        /// 负极极片头宽NG数
        /// </summary>
        public int NJPHeadWidthNGCount;
        /// <summary>
        /// 负极极片尾宽NG数
        /// </summary>
        public int NJPTailWidthNGCount;
        /// <summary>
        /// 负极极片头长NG数
        /// </summary>
        public int NJPHeadLengthNGCount;
        /// <summary>
        /// 负极极片尾长NG数
        /// </summary>
        public int NJPTailLengthNGCount;
        /// <summary>
        /// 负极左极耳肩宽NG数
        /// </summary>
        public int NJELeftShoulderNGCount;
        /// <summary>
        /// 负极右极耳肩宽NG数
        /// </summary>
        public int NJERightShoulderNGCount;
        /// <summary>
        /// 负极极耳宽NG数
        /// </summary>
        public int NJEWidthNGCount;
        /// <summary>
        /// 负极极耳高NG数
        /// </summary>
        public int NJEHeightNGCount;
        /// <summary>
        /// 负极带料高NG数
        /// </summary>
        public int NDLHeightNGCount;
        /// <summary>
        /// 负极极片总宽NG数
        /// </summary>
        public int NJPTotalWidthNGCount;
        /// <summary>
        /// 负极极片涂布高NG数
        /// </summary>
        public int NJPCoatingNGCount;
        /// <summary>
        /// 负极对角线NG数
        /// </summary>
        public int NDiagonalNGCount;

        /// <summary>
        /// 负极相机角度NG总数
        /// </summary>
        public int NAngleNGCount;
        /// <summary>
        /// 负极左上相机角度NG数
        /// </summary>
        public int NLeftUpAngleNGCount;
        /// <summary>
        /// 负极右上相机角度NG数
        /// </summary>
        public int NRightUpAngleNGCount;
        /// <summary>
        /// 负极左下相机角度NG数
        /// </summary>
        public int NLeftDownAngleNGCount;
        /// <summary>
        /// 负极右下相机角度NG数
        /// </summary>
        public int NRightDownAngleNGCount;


        /// <summary>
        /// 负极NG 总数
        /// </summary>
        public int NSumNG;
        /// <summary>
        /// 负极NG 总数王博要的  空片时也累加数量
        /// </summary>
        public int NSumNG_W;
        /// <summary>
        /// 负极来料不良数
        /// </summary>
        public int NIncomingMaterialCount;
        /// <summary>
        /// 负极找边失败数
        /// </summary>
        public int NMeasureLineNGCount;
        /// <summary>
        /// 负极检测总数
        /// </summary>
        public int NSum;
        /// <summary>
        /// 负极极耳打折NG数
        /// </summary>
        public int NJeBevelLimitNGCount;
        /// <summary>
        /// 负极极耳余料NG数
        /// </summary>
        public int NJeOddmentsNGCount;

        /// <summary>
        /// 负极缺角NG总数
        /// </summary>
        public int NBevelNGCount;
        /// <summary>
        /// 负极左上缺角NG数
        /// </summary>
        public int NLeftUpBevelNGCount;
        /// <summary>
        /// 负极右上缺角NG数
        /// </summary>
        public int NRightUpBevelNGCount;
        /// <summary>
        /// 负极左下缺角NG数
        /// </summary>
        public int NLeftDownBevelNGCount;
        /// <summary>
        /// 负极右下缺角NG数
        /// </summary>
        public int NRightDownBevelNGCount;



        /// <summary>
        /// 负极V角度NG总数
        /// </summary>
        public int NVAngleNGCount;
        /// <summary>
        /// 负极V宽度NG总数
        /// </summary>
        public int NVWidthNGCount;
        /// <summary>
        /// 负极V深度NG总数
        /// </summary>
        public int NVDepthNGCount;

        /// <summary>
        /// 负极左上V角度NG数
        /// </summary>
        public int NLeftUpVAngleNGCount;
        /// <summary>
        /// 负极左上V宽度NG数
        /// </summary>
        public int NLeftUpVWidthNGCount;
        /// <summary>
        /// 负极左上V深度NG数
        /// </summary>
        public int NLeftUpVDepthNGCount;

        /// <summary>
        /// 负极右上V角度NG数
        /// </summary>
        public int NRightUpVAngleNGCount;
        /// <summary>
        /// 负极右上V宽度NG数
        /// </summary>
        public int NRightUpVWidthNGCount;
        /// <summary>
        /// 负极右上V深度NG数
        /// </summary>
        public int NRightUpVDepthNGCount;

        /// <summary>
        /// 负极左下V角度NG数
        /// </summary>
        public int NLeftDownVAngleNGCount;
        /// <summary>
        /// 负极左下V宽度NG数
        /// </summary>
        public int NLeftDownVWidthNGCount;
        /// <summary>
        /// 负极左下V深度NG数
        /// </summary>
        public int NLeftDownVDepthNGCount;

        /// <summary>
        /// 负极右下V角度NG数
        /// </summary>
        public int NRightDownVAngleNGCount;
        /// <summary>
        /// 负极右下V宽度NG数
        /// </summary>
        public int NRightDownVWidthNGCount;
        /// <summary>
        /// 负极右下V深度NG数
        /// </summary>
        public int NRightDownVDepthNGCount;

        #endregion

        #region 正极每班次NG数

        /// <summary>
        /// 正极极片头宽NG数
        /// </summary>
        public int PJPHeadWidthNGCount;
        /// <summary>
        /// 正极极片尾宽NG数
        /// </summary>
        public int PJPTailWidthNGCount;
        /// <summary>
        /// 正极极片头长NG数
        /// </summary>
        public int PJPHeadLengthNGCount;
        /// <summary>
        /// 正极极片尾长NG数
        /// </summary>
        public int PJPTailLengthNGCount;
        /// <summary>
        /// 正极左极耳肩宽NG数
        /// </summary>
        public int PJELeftShoulderNGCount;
        /// <summary>
        /// 正极右极耳肩宽NG数
        /// </summary>
        public int PJERightShoulderNGCount;
        /// <summary>
        /// 正极极耳宽NG数
        /// </summary>
        public int PJEWidthNGCount;
        /// <summary>
        /// 正极极耳高NG数
        /// </summary>
        public int PJEHeightNGCount;
        /// <summary>
        /// 正极陶瓷高NG数
        /// </summary>
        public int PCeramicsHeightNGCount;
        /// <summary>
        /// 正极极片总宽NG数
        /// </summary>
        public int PJPTotalWidthNGCount;
        /// <summary>
        /// 正极极片涂布高NG数
        /// </summary>
        public int PJPCoatingNGCount;
        /// <summary>
        /// 正极对角线NG数
        /// </summary>
        public int PDiagonalNGCount;

        /// <summary>
        /// 正极相机角度NG总数
        /// </summary>
        public int PAngleNGCount;
        /// <summary>
        /// 正极左上相机角度NG数
        /// </summary>
        public int PLeftUpAngleNGCount;
        /// <summary>
        /// 正极右上相机角度NG数
        /// </summary>
        public int PRightUpAngleNGCount;
        /// <summary>
        /// 正极左下相机角度NG数
        /// </summary>
        public int PLeftDownAngleNGCount;
        /// <summary>
        /// 正极右下相机角度NG数
        /// </summary>
        public int PRightDownAngleNGCount;


        /// <summary>
        /// 正极NG 总数
        /// </summary>
        public int PSumNG;
        /// <summary>
        /// 正极NG 总数王博要的  空片时也累加数量
        /// </summary>
        public int PSumNG_W;
        /// <summary>
        /// 正极来料不良数
        /// </summary>
        public int PIncomingMaterialCount;
        /// <summary>
        /// 正极找边失败数
        /// </summary>
        public int PMeasureLineNGCount;
        /// <summary>
        /// 正极检测总数
        /// </summary>
        public int PSum;
        /// <summary>
        /// 正极极耳打折NG数
        /// </summary>
        public int PJeBevelLimitNGCount;
        /// <summary>
        /// 正极极耳余料NG数
        /// </summary>
        public int PJeOddmentsNGCount;

        /// <summary>
        /// 正极缺角NG总数
        /// </summary>
        public int PBevelNGCount;
        /// <summary>
        /// 正极左上缺角NG数
        /// </summary>
        public int PLeftUpBevelNGCount;
        /// <summary>
        /// 正极右上缺角NG数
        /// </summary>
        public int PRightUpBevelNGCount;
        /// <summary>
        /// 正极左下缺角NG数
        /// </summary>
        public int PLeftDownBevelNGCount;
        /// <summary>
        /// 正极右下缺角NG数
        /// </summary>
        public int PRightDownBevelNGCount;



        /// <summary>
        /// 正极V角度NG总数
        /// </summary>
        public int PVAngleNGCount;
        /// <summary>
        /// 正极V宽度NG总数
        /// </summary>
        public int PVWidthNGCount;
        /// <summary>
        /// 正极V深度NG总数
        /// </summary>
        public int PVDepthNGCount;

        /// <summary>
        /// 正极左上V角度NG数
        /// </summary>
        public int PLeftUpVAngleNGCount;
        /// <summary>
        /// 正极左上V宽度NG数
        /// </summary>
        public int PLeftUpVWidthNGCount;
        /// <summary>
        /// 正极左上V深度NG数
        /// </summary>
        public int PLeftUpVDepthNGCount;

        /// <summary>
        /// 正极右上V角度NG数
        /// </summary>
        public int PRightUpVAngleNGCount;
        /// <summary>
        /// 正极右上V宽度NG数
        /// </summary>
        public int PRightUpVWidthNGCount;
        /// <summary>
        /// 正极右上V深度NG数
        /// </summary>
        public int PRightUpVDepthNGCount;

        /// <summary>
        /// 正极左下V角度NG数
        /// </summary>
        public int PLeftDownVAngleNGCount;
        /// <summary>
        /// 正极左下V宽度NG数
        /// </summary>
        public int PLeftDownVWidthNGCount;
        /// <summary>
        /// 正极左下V深度NG数
        /// </summary>
        public int PLeftDownVDepthNGCount;

        /// <summary>
        /// 正极右下V角度NG数
        /// </summary>
        public int PRightDownVAngleNGCount;
        /// <summary>
        /// 正极右下V宽度NG数
        /// </summary>
        public int PRightDownVWidthNGCount;
        /// <summary>
        /// 正极右下V深度NG数
        /// </summary>
        public int PRightDownVDepthNGCount;

        #endregion

        #region 负极每班次NG数-优先级



        /// <summary>
        /// 负极极片头宽NG数-优先级
        /// </summary>
        public int NJPHeadWidthNGCount_YXJ;
        /// <summary>
        /// 负极极片尾宽NG数-优先级
        /// </summary>
        public int NJPTailWidthNGCount_YXJ;
        /// <summary>
        /// 负极极片头长NG数-优先级
        /// </summary>
        public int NJPHeadLengthNGCount_YXJ;
        /// <summary>
        /// 负极极片尾长NG数-优先级
        /// </summary>
        public int NJPTailLengthNGCount_YXJ;
        /// <summary>
        /// 负极左极耳肩宽NG数-优先级
        /// </summary>
        public int NJELeftShoulderNGCount_YXJ;
        /// <summary>
        /// 负极右极耳肩宽NG数-优先级
        /// </summary>
        public int NJERightShoulderNGCount_YXJ;
        /// <summary>
        /// 负极极耳宽NG数-优先级
        /// </summary>
        public int NJEWidthNGCount_YXJ;
        /// <summary>
        /// 负极极耳高NG数-优先级
        /// </summary>
        public int NJEHeightNGCount_YXJ;
        /// <summary>
        /// 负极带料高NG数-优先级
        /// </summary>
        public int NDLHeightNGCount_YXJ;
        /// <summary>
        /// 负极极片总宽NG数-优先级
        /// </summary>
        public int NJPTotalWidthNGCount_YXJ;
        /// <summary>
        /// 负极极片涂布高NG数-优先级
        /// </summary>
        public int NJPCoatingNGCount_YXJ;
        /// <summary>
        /// 负极对角线NG数-优先级
        /// </summary>
        public int NDiagonalNGCount_YXJ;

        /// <summary>
        /// 负极相机角度NG总数-优先级
        /// </summary>
        public int NAngleNGCount_YXJ;
        /// <summary>
        /// 负极左上相机角度NG数-优先级
        /// </summary>
        public int NLeftUpAngleNGCount_YXJ;
        /// <summary>
        /// 负极右上相机角度NG数-优先级
        /// </summary>
        public int NRightUpAngleNGCount_YXJ;
        /// <summary>
        /// 负极左下相机角度NG数-优先级
        /// </summary>
        public int NLeftDownAngleNGCount_YXJ;
        /// <summary>
        /// 负极右下相机角度NG数-优先级
        /// </summary>
        public int NRightDownAngleNGCount_YXJ;


        /// <summary>
        /// 负极NG 总数-优先级
        /// </summary>
        public int NSumNG_YXJ;
        /// <summary>
        /// 负极NG 总数王博要的  空片时也累加数量-优先级
        /// </summary>
        public int NSumNG_W_YXJ;
        /// <summary>
        /// 负极来料不良数-优先级
        /// </summary>
        public int NIncomingMaterialCount_YXJ;
        /// <summary>
        /// 负极找边失败数-优先级
        /// </summary>
        public int NMeasureLineNGCount_YXJ;
        /// <summary>
        /// 负极检测总数-优先级
        /// </summary>
        public int NSum_YXJ;
        /// <summary>
        /// 负极极耳打折NG数-优先级
        /// </summary>
        public int NJeBevelLimitNGCount_YXJ;
        /// <summary>
        /// 负极极耳余料NG数-优先级
        /// </summary>
        public int NJeOddmentsNGCount_YXJ;

        /// <summary>
        /// 负极缺角NG总数-优先级
        /// </summary>
        public int NBevelNGCount_YXJ;
        /// <summary>
        /// 负极左上缺角NG数-优先级
        /// </summary>
        public int NLeftUpBevelNGCount_YXJ;
        /// <summary>
        /// 负极右上缺角NG数-优先级
        /// </summary>
        public int NRightUpBevelNGCount_YXJ;
        /// <summary>
        /// 负极左下缺角NG数-优先级
        /// </summary>
        public int NLeftDownBevelNGCount_YXJ;
        /// <summary>
        /// 负极右下缺角NG数-优先级
        /// </summary>
        public int NRightDownBevelNGCount_YXJ;



        /// <summary>
        /// 负极V角度NG总数-优先级
        /// </summary>
        public int NVAngleNGCount_YXJ;
        /// <summary>
        /// 负极V宽度NG总数-优先级
        /// </summary>
        public int NVWidthNGCount_YXJ;
        /// <summary>
        /// 负极V深度NG总数-优先级
        /// </summary>
        public int NVDepthNGCount_YXJ;

        /// <summary>
        /// 负极左上V角度NG数-优先级
        /// </summary>
        public int NLeftUpVAngleNGCount_YXJ;
        /// <summary>
        /// 负极左上V宽度NG数-优先级
        /// </summary>
        public int NLeftUpVWidthNGCount_YXJ;
        /// <summary>
        /// 负极左上V深度NG数-优先级
        /// </summary>
        public int NLeftUpVDepthNGCount_YXJ;

        /// <summary>
        /// 负极右上V角度NG数-优先级
        /// </summary>
        public int NRightUpVAngleNGCount_YXJ;
        /// <summary>
        /// 负极右上V宽度NG数-优先级
        /// </summary>
        public int NRightUpVWidthNGCount_YXJ;
        /// <summary>
        /// 负极右上V深度NG数-优先级
        /// </summary>
        public int NRightUpVDepthNGCount_YXJ;

        /// <summary>
        /// 负极左下V角度NG数-优先级
        /// </summary>
        public int NLeftDownVAngleNGCount_YXJ;
        /// <summary>
        /// 负极左下V宽度NG数-优先级
        /// </summary>
        public int NLeftDownVWidthNGCount_YXJ;
        /// <summary>
        /// 负极左下V深度NG数-优先级
        /// </summary>
        public int NLeftDownVDepthNGCount_YXJ;

        /// <summary>
        /// 负极右下V角度NG数-优先级
        /// </summary>
        public int NRightDownVAngleNGCount_YXJ;
        /// <summary>
        /// 负极右下V宽度NG数-优先级
        /// </summary>
        public int NRightDownVWidthNGCount_YXJ;
        /// <summary>
        /// 负极右下V深度NG数-优先级
        /// </summary>
        public int NRightDownVDepthNGCount_YXJ;

        #endregion

        #region 正极每班次NG数-优先级

        /// <summary>
        /// 正极极片头宽NG数-优先级
        /// </summary>
        public int PJPHeadWidthNGCount_YXJ;
        /// <summary>
        /// 正极极片尾宽NG数-优先级
        /// </summary>
        public int PJPTailWidthNGCount_YXJ;
        /// <summary>
        /// 正极极片头长NG数-优先级
        /// </summary>
        public int PJPHeadLengthNGCount_YXJ;
        /// <summary>
        /// 正极极片尾长NG数-优先级
        /// </summary>
        public int PJPTailLengthNGCount_YXJ;
        /// <summary>
        /// 正极左极耳肩宽NG数-优先级
        /// </summary>
        public int PJELeftShoulderNGCount_YXJ;
        /// <summary>
        /// 正极右极耳肩宽NG数-优先级
        /// </summary>
        public int PJERightShoulderNGCount_YXJ;
        /// <summary>
        /// 正极极耳宽NG数-优先级
        /// </summary>
        public int PJEWidthNGCount_YXJ;
        /// <summary>
        /// 正极极耳高NG数-优先级
        /// </summary>
        public int PJEHeightNGCount_YXJ;
        /// <summary>
        /// 正极陶瓷高NG数-优先级
        /// </summary>
        public int PCeramicsHeightNGCount_YXJ;
        /// <summary>
        /// 正极极片总宽NG数-优先级
        /// </summary>
        public int PJPTotalWidthNGCount_YXJ;
        /// <summary>
        /// 正极极片涂布高NG数-优先级
        /// </summary>
        public int PJPCoatingNGCount_YXJ;
        /// <summary>
        /// 正极对角线NG数-优先级
        /// </summary>
        public int PDiagonalNGCount_YXJ;

        /// <summary>
        /// 正极相机角度NG总数-优先级
        /// </summary>
        public int PAngleNGCount_YXJ;
        /// <summary>
        /// 正极左上相机角度NG数-优先级
        /// </summary>
        public int PLeftUpAngleNGCount_YXJ;
        /// <summary>
        /// 正极右上相机角度NG数-优先级
        /// </summary>
        public int PRightUpAngleNGCount_YXJ;
        /// <summary>
        /// 正极左下相机角度NG数-优先级
        /// </summary>
        public int PLeftDownAngleNGCount_YXJ;
        /// <summary>
        /// 正极右下相机角度NG数-优先级
        /// </summary>
        public int PRightDownAngleNGCount_YXJ;


        /// <summary>
        /// 正极NG 总数-优先级
        /// </summary>
        public int PSumNG_YXJ;
        /// <summary>
        /// 正极NG 总数王博要的  空片时也累加数量-优先级
        /// </summary>
        public int PSumNG_W_YXJ;
        /// <summary>
        /// 正极来料不良数-优先级
        /// </summary>
        public int PIncomingMaterialCount_YXJ;
        /// <summary>
        /// 正极找边失败数-优先级
        /// </summary>
        public int PMeasureLineNGCount_YXJ;
        /// <summary>
        /// 正极检测总数-优先级
        /// </summary>
        public int PSum_YXJ;
        /// <summary>
        /// 正极极耳打折NG数-优先级
        /// </summary>
        public int PJeBevelLimitNGCount_YXJ;
        /// <summary>
        /// 正极极耳余料NG数-优先级
        /// </summary>
        public int PJeOddmentsNGCount_YXJ;

        /// <summary>
        /// 正极缺角NG总数-优先级
        /// </summary>
        public int PBevelNGCount_YXJ;
        /// <summary>
        /// 正极左上缺角NG数-优先级
        /// </summary>
        public int PLeftUpBevelNGCount_YXJ;
        /// <summary>
        /// 正极右上缺角NG数-优先级
        /// </summary>
        public int PRightUpBevelNGCount_YXJ;
        /// <summary>
        /// 正极左下缺角NG数-优先级
        /// </summary>
        public int PLeftDownBevelNGCount_YXJ;
        /// <summary>
        /// 正极右下缺角NG数-优先级
        /// </summary>
        public int PRightDownBevelNGCount_YXJ;



        /// <summary>
        /// 正极V角度NG总数-优先级
        /// </summary>
        public int PVAngleNGCount_YXJ;
        /// <summary>
        /// 正极V宽度NG总数-优先级
        /// </summary>
        public int PVWidthNGCount_YXJ;
        /// <summary>
        /// 正极V深度NG总数-优先级
        /// </summary>
        public int PVDepthNGCount_YXJ;

        /// <summary>
        /// 正极左上V角度NG数-优先级
        /// </summary>
        public int PLeftUpVAngleNGCount_YXJ;
        /// <summary>
        /// 正极左上V宽度NG数-优先级
        /// </summary>
        public int PLeftUpVWidthNGCount_YXJ;
        /// <summary>
        /// 正极左上V深度NG数-优先级
        /// </summary>
        public int PLeftUpVDepthNGCount_YXJ;

        /// <summary>
        /// 正极右上V角度NG数-优先级
        /// </summary>
        public int PRightUpVAngleNGCount_YXJ;
        /// <summary>
        /// 正极右上V宽度NG数-优先级
        /// </summary>
        public int PRightUpVWidthNGCount_YXJ;
        /// <summary>
        /// 正极右上V深度NG数-优先级
        /// </summary>
        public int PRightUpVDepthNGCount_YXJ;

        /// <summary>
        /// 正极左下V角度NG数-优先级
        /// </summary>
        public int PLeftDownVAngleNGCount_YXJ;
        /// <summary>
        /// 正极左下V宽度NG数-优先级
        /// </summary>
        public int PLeftDownVWidthNGCount_YXJ;
        /// <summary>
        /// 正极左下V深度NG数-优先级
        /// </summary>
        public int PLeftDownVDepthNGCount_YXJ;

        /// <summary>
        /// 正极右下V角度NG数-优先级
        /// </summary>
        public int PRightDownVAngleNGCount_YXJ;
        /// <summary>
        /// 正极右下V宽度NG数-优先级
        /// </summary>
        public int PRightDownVWidthNGCount_YXJ;
        /// <summary>
        /// 正极右下V深度NG数-优先级
        /// </summary>
        public int PRightDownVDepthNGCount_YXJ;

        #endregion

        #region 负极每极卷NG数

        /// <summary>
        /// 负极第1次换卷开始时间
        /// </summary>
        public string NStarttime_J1;
        /// <summary>
        /// 负极第2次换卷开始时间
        /// </summary>
        public string NStarttime_J2;

        /// <summary>
        /// 负极极片头宽NG数_J
        /// </summary>
        public int NJPHeadWidthNGCount_J;
        /// <summary>
        /// 负极极片尾宽NG数_J
        /// </summary>
        public int NJPTailWidthNGCount_J;
        /// <summary>
        /// 负极极片头长NG数_J
        /// </summary>
        public int NJPHeadLengthNGCount_J;
        /// <summary>
        /// 负极极片尾长NG数_J
        /// </summary>
        public int NJPTailLengthNGCount_J;
        /// <summary>
        /// 负极左极耳肩宽NG数_J
        /// </summary>
        public int NJELeftShoulderNGCount_J;
        /// <summary>
        /// 负极右极耳肩宽NG数_J
        /// </summary>
        public int NJERightShoulderNGCount_J;
        /// <summary>
        /// 负极极耳宽NG数_J
        /// </summary>
        public int NJEWidthNGCount_J;
        /// <summary>
        /// 负极极耳高NG数_J
        /// </summary>
        public int NJEHeightNGCount_J;
        /// <summary>
        /// 负极带料高NG数_J
        /// </summary>
        public int NDLHeightNGCount_J;
        /// <summary>
        /// 负极极片总宽NG数_J
        /// </summary>
        public int NJPTotalWidthNGCount_J;
        /// <summary>
        /// 负极极片涂布高NG数_J
        /// </summary>
        public int NJPCoatingNGCount_J;
        /// <summary>
        /// 负极对角线NG数_J
        /// </summary>
        public int NDiagonalNGCount_J;

        /// <summary>
        /// 负极相机角度NG总数_J
        /// </summary>
        public int NAngleNGCount_J;
        /// <summary>_
        /// 负极左上相机角度NG数_J
        /// </summary>
        public int NLeftUpAngleNGCount_J;
        /// <summary>
        /// 负极右上相机角度NG数_J
        /// </summary>
        public int NRightUpAngleNGCount_J;
        /// <summary>
        /// 负极左下相机角度NG数_J
        /// </summary>
        public int NLeftDownAngleNGCount_J;
        /// <summary>
        /// 负极右下相机角度NG数_J
        /// </summary>
        public int NRightDownAngleNGCount_J;


        /// <summary>
        /// 负极NG 总数_J
        /// </summary>
        public int NSumNG_J;
        /// <summary>
        /// 负极来料不良数
        /// </summary>
        public int NIncomingMaterialCount_J;
        /// <summary>
        /// 负极找边失败数_J
        /// </summary>
        public int NMeasureLineNGCount_J;
        /// <summary>
        /// 负极检测总数_J
        /// </summary>
        public int NSum_J;
        /// <summary>
        /// 负极极耳打折NG数_J
        /// </summary>
        public int NJeBevelLimitNGCount_J;
        /// <summary>
        /// 负极极耳余料NG数_J
        /// </summary>
        public int NJeOddmentsNGCount_J;




        /// <summary>
        /// 负极缺角NG总数_J
        /// </summary>
        public int NBevelNGCount_J;
        /// <summary>
        /// 负极左上缺角NG数_J
        /// </summary>
        public int NLeftUpBevelNGCount_J;
        /// <summary>
        /// 负极右上缺角NG数_J
        /// </summary>
        public int NRightUpBevelNGCount_J;
        /// <summary>
        /// 负极左下缺角NG数_J
        /// </summary>
        public int NLeftDownBevelNGCount_J;
        /// <summary>
        /// 负极右下缺角NG数_J
        /// </summary>
        public int NRightDownBevelNGCount_J;


        /// <summary>
        /// 负极V角度NG总数_J
        /// </summary>
        public int NVAngleNGCount_J;
        /// <summary>
        /// 负极V宽度NG总数_J
        /// </summary>
        public int NVWidthNGCount_J;
        /// <summary>
        /// 负极V深度NG总数_J
        /// </summary>
        public int NVDepthNGCount_J;

        /// <summary>
        /// 负极左上V角度NG数_J
        /// </summary>
        public int NLeftUpVAngleNGCount_J;
        /// <summary>
        /// 负极左上V宽度NG数_J
        /// </summary>
        public int NLeftUpVWidthNGCount_J;
        /// <summary>
        /// 负极左上V深度NG数_J
        /// </summary>
        public int NLeftUpVDepthNGCount_J;

        /// <summary>
        /// 负极右上V角度NG数_J
        /// </summary>
        public int NRightUpVAngleNGCount_J;
        /// <summary>
        /// 负极右上V宽度NG数_J
        /// </summary>
        public int NRightUpVWidthNGCount_J;
        /// <summary>
        /// 负极右上V深度NG数_J
        /// </summary>
        public int NRightUpVDepthNGCount_J;

        /// <summary>
        /// 负极左下V角度NG数
        /// </summary>
        public int NLeftDownVAngleNGCount_J;
        /// <summary>
        /// 负极左下V宽度NG数_J
        /// </summary>
        public int NLeftDownVWidthNGCount_J;
        /// <summary>
        /// 负极左下V深度NG数_J
        /// </summary>
        public int NLeftDownVDepthNGCount_J;

        /// <summary>
        /// 负极右下V角度NG数_J
        /// </summary>
        public int NRightDownVAngleNGCount_J;
        /// <summary>
        /// 负极右下V宽度NG数_J
        /// </summary>
        public int NRightDownVWidthNGCount_J;
        /// <summary>
        /// 负极右下V深度NG数_J
        /// </summary>
        public int NRightDownVDepthNGCount_J;

        #endregion

        #region 正极每极卷NG数





        /// <summary>
        /// 正极第1次换卷开始时间
        /// </summary>
        public string PStarttime_J1;
        /// <summary>
        /// 正极第2次换卷开始时间
        /// </summary>
        public string PStarttime_J2;
        /// <summary>
        /// 正极极片头宽NG数
        /// </summary>
        public int PJPHeadWidthNGCount_J;
        /// <summary>
        /// 正极极片尾宽NG数_J
        /// </summary>
        public int PJPTailWidthNGCount_J;
        /// <summary>
        /// 正极极片头长NG数_J
        /// </summary>
        public int PJPHeadLengthNGCount_J;
        /// <summary>
        /// 正极极片尾长NG数_J
        /// </summary>
        public int PJPTailLengthNGCount_J;
        /// <summary>
        /// 正极左极耳肩宽NG数_J
        /// </summary>
        public int PJELeftShoulderNGCount_J;
        /// <summary>
        /// 正极右极耳肩宽NG数_J
        /// </summary>
        public int PJERightShoulderNGCount_J;
        /// <summary>
        /// 正极极耳宽NG数_J
        /// </summary>
        public int PJEWidthNGCount_J;
        /// <summary>
        /// 正极极耳高NG数_J
        /// </summary>
        public int PJEHeightNGCount_J;
        /// <summary>
        /// 正极陶瓷高NG数_J
        /// </summary>
        public int PCeramicsHeightNGCount_J;
        /// <summary>
        /// 正极极片总宽NG数_J
        /// </summary>
        public int PJPTotalWidthNGCount_J;
        /// <summary>
        /// 正极极片涂布高NG数_J
        /// </summary>
        public int PJPCoatingNGCount_J;
        /// <summary>
        /// 正极对角线NG数_J
        /// </summary>
        public int PDiagonalNGCount_J;

        /// <summary>
        /// 正极相机角度NG总数_J
        /// </summary>
        public int PAngleNGCount_J;
        /// <summary>
        /// 正极左上相机角度NG数_J
        /// </summary>
        public int PLeftUpAngleNGCount_J;
        /// <summary>
        /// 正极右上相机角度NG数_J
        /// </summary>
        public int PRightUpAngleNGCount_J;
        /// <summary>
        /// 正极左下相机角度NG数_J
        /// </summary>
        public int PLeftDownAngleNGCount_J;
        /// <summary>
        /// 正极右下相机角度NG数_J
        /// </summary>
        public int PRightDownAngleNGCount_J;



        /// <summary>
        /// 正极NG 总数_J
        /// </summary>
        public int PSumNG_J;
        /// <summary>
        /// 正极来料不良数_J
        /// </summary>
        public int PIncomingMaterialCount_J;
        /// <summary>
        /// 正极找边失败数_J
        /// </summary>
        public int PMeasureLineNGCount_J;
        /// <summary>
        /// 正极检测总数_J
        /// </summary>
        public int PSum_J;
        /// <summary>
        /// 正极极耳打折NG数_J
        /// </summary>
        public int PJeBevelLimitNGCount_J;
        /// <summary>
        /// 正极极耳余料NG数_J
        /// </summary>
        public int PJeOddmentsNGCount_J;

        /// <summary>
        /// 正极缺角NG总数_J
        /// </summary>
        public int PBevelNGCount_J;
        /// <summary>
        /// 正极左上缺角NG数_J
        /// </summary>
        public int PLeftUpBevelNGCount_J;
        /// <summary>
        /// 正极右上缺角NG数_J
        /// </summary>
        public int PRightUpBevelNGCount_J;
        /// <summary>
        /// 正极左下缺角NG数_J
        /// </summary>
        public int PLeftDownBevelNGCount_J;
        /// <summary>
        /// 正极右下缺角NG数_J
        /// </summary>
        public int PRightDownBevelNGCount_J;


        /// <summary>
        /// 正极V角度NG总数_J
        /// </summary>
        public int PVAngleNGCount_J;
        /// <summary>
        /// 正极V宽度NG总数_J
        /// </summary>
        public int PVWidthNGCount_J;
        /// <summary>
        /// 正极V深度NG总数_J
        /// </summary>
        public int PVDepthNGCount_J;

        /// <summary>
        /// 正极左上V角度NG数_J
        /// </summary>
        public int PLeftUpVAngleNGCount_J;
        /// <summary>
        /// 正极左上V宽度NG数_J
        /// </summary>
        public int PLeftUpVWidthNGCount_J;
        /// <summary>
        /// 正极左上V深度NG数_J
        /// </summary>
        public int PLeftUpVDepthNGCount_J;

        /// <summary>
        /// 正极右上V角度NG数_J
        /// </summary>
        public int PRightUpVAngleNGCount_J;
        /// <summary>
        /// 正极右上V宽度NG数_J
        /// </summary>
        public int PRightUpVWidthNGCount_J;
        /// <summary>
        /// 正极右上V深度NG数_J
        /// </summary>
        public int PRightUpVDepthNGCount_J;

        /// <summary>
        /// 正极左下V角度NG数_J
        /// </summary>
        public int PLeftDownVAngleNGCount_J;
        /// <summary>
        /// 正极左下V宽度NG数_J
        /// </summary>
        public int PLeftDownVWidthNGCount_J;
        /// <summary>
        /// 正极左下V深度NG数_J
        /// </summary>
        public int PLeftDownVDepthNGCount_J;

        /// <summary>
        /// 正极右下V角度NG数_J
        /// </summary>
        public int PRightDownVAngleNGCount_J;
        /// <summary>
        /// 正极右下V宽度NG数_J
        /// </summary>
        public int PRightDownVWidthNGCount_J;
        /// <summary>
        /// 正极右下V深度NG数_J
        /// </summary>
        public int PRightDownVDepthNGCount_J;

        #endregion

        #region 王博要的NG分类　按１２３档分类
        /// <summary>
        /// 正极1档NG分类-班次
        /// </summary>
        public int PNGOne;
        /// <summary>
        /// 正极2档NG分类-班次
        /// </summary>
        public int PNGTwo;
        /// <summary>
        /// 正极3档NG分类-班次
        /// </summary>
        public int PNGThree;
        /// <summary>
        /// 负极1档NG分类-班次
        /// </summary>
        public int NNGOne;
        /// <summary>
        /// 负极2档NG分类-班次
        /// </summary>
        public int NNGTwo;
        /// <summary>
        /// 负极3档NG分类-班次
        /// </summary>
        public int NNGThree;



        /// <summary>
        /// 正极1档NG分类-极卷
        /// </summary>
        public int PNGOne_J;
        /// <summary>
        /// 正极2档NG分类-极卷
        /// </summary>
        public int PNGTwo_J;
        /// <summary>
        /// 正极3档NG分类-极卷
        /// </summary>
        public int PNGThree_J;
        /// <summary>
        /// 负极1档NG分类-极卷
        /// </summary>
        public int NNGOne_J;
        /// <summary>
        /// 负极2档NG分类-极卷
        /// </summary>
        public int NNGTwo_J;
        /// <summary>
        /// 负极3档NG分类-极卷
        /// </summary>
        public int NNGThree_J;

        #endregion
        #region 负极每小时优先级NG数
        /// <summary>
        /// 负极第1次分时统计开始时间
        /// </summary>
        public string NStarttime_Hour1;
        /// <summary>
        /// 负极第2次分时统计开始时间
        /// </summary>
        public string NStarttime_Hour2;
        /// <summary>
        /// 负极NG 总数_P优先级
        /// </summary>
        public int NSumNG_P;
        /// <summary>
        /// 负极检测总数_P优先级
        /// </summary>
        public int NSum_P;

        /// <summary>
        /// 负极极片头宽NG数_P优先级
        /// </summary>
        public int NJPHeadWidthNGCount_P;
        /// <summary>
        /// 负极极片尾宽NG数_P优先级
        /// </summary>
        public int NJPTailWidthNGCount_P;
        /// <summary>
        /// 负极极片头长NG数_P优先级
        /// </summary>
        public int NJPHeadLengthNGCount_P;
        /// <summary>
        /// 负极极片尾长NG数_P优先级
        /// </summary>
        public int NJPTailLengthNGCount_P;
        /// <summary>
        /// 负极极耳左肩宽NG数_P优先级
        /// </summary>
        public int NJELeftShoulderNGCount_P;
        /// <summary>
        /// 负极极耳右肩宽NG数_P优先级
        /// </summary>
        public int NJERightShoulderNGCount_P;
        /// <summary>
        /// 负极对角线NG数_P优先级
        /// </summary>
        public int NDiagonalNGCount_P;
        /// <summary>
        /// 负极V角度NG数_P优先级
        /// </summary>
        public int NVAngleNGCount_P;
        /// <summary>
        /// 负极V宽度NG数_P优先级
        /// </summary>
        public int NVWidthNGCount_P;
        /// <summary>
        /// 负极V深度NG数_P优先级
        /// </summary>
        public int NVDepthNGCount_P;

        /// <summary>
        /// 负极极耳宽NG数_P优先级
        /// </summary>
        public int NJEWidthNGCount_P;
        /// <summary>
        /// 负极极耳高NG数_P优先级
        /// </summary>
        public int NJEHeightNGCount_P;
        /// <summary>
        /// 负极带料高NG数_P优先级
        /// </summary>
        public int NDLHeightNGCount_P;
        /// <summary>
        /// 负极极片总宽NG数_P优先级
        /// </summary>
        public int NJPTotalWidthNGCount_P;
        /// <summary>
        /// 负极极片涂布高NG数_P优先级
        /// </summary>
        public int NJPCoatingNGCount_P;
        /// <summary>
        /// 负极相机角度NG总数_P优先级
        /// </summary>
        public int NAngleNGCount_P;
        /// <summary>
        /// 负极找边失败数_P优先级
        /// </summary>
        public int NMeasureLineNGCount_P;
        /// <summary>
        /// 负极极耳打折NG数_P优先级
        /// </summary>
        public int NJeBevelLimitNGCount_P;
        /// <summary>
        /// 负极极耳余料NG数_P优先级
        /// </summary>
        public int NJeOddmentsNGCount_P;

        /// <summary>
        /// 负极缺角NG总数_P（823叫V角余料）优先级
        /// </summary>
        public int NBevelNGCount_P;
        /// <summary>
        /// 负极V角NG总数_P优先级
        /// </summary>
        public int NVNGCount_P;



        #endregion

        #region 正极每小时优先级NG数
        /// <summary>
        /// 正极第1次分时统计开始时间
        /// </summary>
        public string PStarttime_Hour1 = "";
        /// <summary>
        /// 正极第2次分时统计开始时间
        /// </summary>
        public string PStarttime_Hour2 = "";

        /// <summary>
        /// 正极NG 总数_P优先级
        /// </summary>
        public int PSumNG_P;
        /// <summary>
        /// 正极检测总数_P优先级
        /// </summary>
        public int PSum_P;

        /// <summary>
        /// 正极极片头宽NG数_P优先级
        /// </summary>
        public int PJPHeadWidthNGCount_P;
        /// <summary>
        /// 正极极片尾宽NG数_P优先级
        /// </summary>
        public int PJPTailWidthNGCount_P;
        /// <summary>
        /// 正极极片头长NG数_P优先级
        /// </summary>
        public int PJPHeadLengthNGCount_P;
        /// <summary>
        /// 正极极片尾长NG数_P优先级
        /// </summary>
        public int PJPTailLengthNGCount_P;

        /// <summary>
        /// 正极极耳左肩宽NG数_P优先级
        /// </summary>
        public int PJELeftShoulderNGCount_P;
        /// <summary>
        /// 正极极耳右肩宽NG数_P优先级
        /// </summary>
        public int PJERightShoulderNGCount_P;
        /// <summary>
        /// 正极对角线NG数_P优先级
        /// </summary>
        public int PDiagonalNGCount_P;
        /// <summary>
        /// 正极V角度NG数_P优先级
        /// </summary>
        public int PVAngleNGCount_P;
        /// <summary>
        /// 正极V宽度NG数_P优先级
        /// </summary>
        public int PVWidthNGCount_P;
        /// <summary>
        /// 正极V深度NG数_P优先级
        /// </summary>
        public int PVDepthNGCount_P;
        /// <summary>
        /// 正极极耳宽NG数_P优先级
        /// </summary>
        public int PJEWidthNGCount_P;
        /// <summary>
        /// 正极极耳高NG数_P优先级
        /// </summary>
        public int PJEHeightNGCount_P;
        /// <summary>
        /// 正极陶瓷高NG数_P优先级
        /// </summary>
        public int PCeramicHeightNGCount_P;
        /// <summary>
        /// 正极极片总宽NG数_P优先级
        /// </summary>
        public int PJPTotalWidthNGCount_P;
        /// <summary>
        /// 正极极片涂布高NG数_P优先级
        /// </summary>
        public int PJPCoatingNGCount_P;
        /// <summary>
        /// 正极相机角度NG总数_P优先级
        /// </summary>
        public int PAngleNGCount_P;
        /// <summary>
        /// 正极找边失败数_P优先级
        /// </summary>
        public int PMeasureLineNGCount_P;
        /// <summary>
        /// 正极极耳打折NG数_P优先级
        /// </summary>
        public int PJeBevelLimitNGCount_P;
        /// <summary>
        /// 正极极耳余料NG数_P优先级
        /// </summary>
        public int PJeOddmentsNGCount_P;
        /// <summary>
        /// 正极缺角NG总数_P（823叫V角余料）优先级
        /// </summary>
        public int PBevelNGCount_P;
        /// <summary>
        /// 正极V角NG总数_P优先级
        /// </summary>
        public int PVNGCount_P;
        #endregion
    }

    [Serializable]
    class MySet
    {
        #region 通讯设置
        /// <summary>
        /// 通讯方式
        /// </summary>
        public string StrPlcTcp = "CIP";

        /// <summary>
        /// 通讯IP地址
        /// </summary>
        public string IP = "192.168.250.1";

        /// <summary>
        /// 通讯上位机IP地址
        /// </summary>
        public string ComputerIP = "192.168.250.113";

        /// <summary>
        /// 通讯端口
        /// </summary>
        public string DClient;
        /// <summary>
        /// 通讯客户端节点
        /// </summary>
        public string Client;

        /// <summary>
        /// 拍照触发地址
        /// </summary>
        public string TriggerPhotographAddrees = "0102";
        /// <summary>
        /// 允许发送NG数地址
        /// </summary>
        public string NGisok = "DCS100";
        /// <summary>
        /// NG数地址
        /// </summary>
        public string NGcountAddress = "DCS202";
        /// <summary>
        /// OKNG信号发送地址
        /// </summary>
        public string OKNGAddress = "0115";
        /// <summary>
        /// 发送OK值
        /// </summary>
        public int OK;
        /// <summary>
        /// 发送NG值
        /// </summary>
        public int NG;
        /// <summary>
        /// 心跳地址
        /// </summary>
        public string HeartbeatAddress = "0110";
        /// <summary>
        /// 工艺参数地址
        /// </summary>
        public string CraftAddress = "0116";
        /// <summary>
        /// 读取工艺参数地址
        /// </summary>
        public string ReadCraftAddress = "SET_CCD";
        /// <summary>
        /// 负极极卷码
        /// </summary>
        public string PoleReelN;
        /// <summary>
        /// 正极极卷码
        /// </summary>
        public string PoleReelP;

        /// <summary>
        /// 负极换卷地址
        /// </summary>
        public string ChangeOfLapAddressN;
        /// <summary>
        /// 正极换卷地址
        /// </summary>
        public string ChangeOfLapAddressP;


        /// <summary>
        /// 负极卷径地址
        /// </summary>
        public string RollingDiameterAddressN;
        /// <summary>
        /// 正极卷径地址
        /// </summary>
        public string RollingDiameterAddressP;

        /// <summary>
        ///负极刷卡登录校验  先刷卡后读取  PLC去判定哪个工位刷卡器刷卡以及是否有效
        /// </summary>
        public string LoginVerifyN;
        /// <summary>
        ///正极刷卡登录校验  先刷卡后读取  PLC去判定哪个工位刷卡器刷卡以及是否有效
        /// </summary>
        public string LoginVerifyP;
        /// <summary>
        ///刷卡登录用户名  校验成功后 读取用户名
        /// </summary>
        public string LoginUserName;

        /// <summary>
        ///刷卡登录权限  校验成功后 读取权限
        /// </summary>
        public string LoginUserPower;




        #endregion

        #region 负极工艺
        /// <summary>
        /// 负极极片头宽开关-开发者
        /// </summary>
        public bool NJPHeadWidthSwitch_Developer;
        /// <summary>
        /// 负极极片头宽开关
        /// </summary>
        public bool NJPHeadWidthSwitch;
        /// <summary>
        /// 负极极片头宽最小值
        /// </summary>
        public double NJPHeadWidthMin;
        /// <summary>
        /// 负极极片头宽最大值
        /// </summary>
        public double NJPHeadWidthMax;
        /// <summary>
        /// 负极极片头宽标准值
        /// </summary>
        public double NJPHeadWidthStandard;
        /// <summary>
        /// 负极极片头宽自定义命名
        /// </summary>
        public string NJPHeadWidthName = "极片头宽";
        /// <summary>
        /// 负极极片头宽补偿值
        /// </summary>
        public double NJPHeadWidthCompensate;
        /// <summary>
        /// 负极极片头宽工艺范围
        /// </summary>
        public string NJPHeadWidthRange;

        /// <summary>
        /// 负极极片尾宽开关-开发者
        /// </summary>
        public bool NJPTailWidthSwitch_Developer;
        /// <summary>
        /// 负极极片尾宽开关
        /// </summary>
        public bool NJPTailWidthSwitch;
        /// <summary>
        /// 负极极片尾宽最小值
        /// </summary>
        public double NJPTailWidthMin;
        /// <summary>
        /// 负极极片尾宽最大值
        /// </summary>
        public double NJPTailWidthMax;
        /// <summary>
        /// 负极极片尾宽标准值
        /// </summary>
        public double NJPTailWidthStandard;
        /// <summary>
        /// 负极极片尾宽自定义命名
        /// </summary>
        public string NJPTailWidthName = "极片尾宽";
        /// <summary>
        /// 负极极片尾宽补偿值
        /// </summary>
        public double NJPTailWidthCompensate;
        /// <summary>
        /// 负极极片尾宽工艺范围
        /// </summary>
        public string NJPTailWidthRange;

        /// <summary>
        /// 负极极片头长开关-开发者
        /// </summary>
        public bool NJPHeadLengthSwitch_Developer;
        /// <summary>
        /// 负极极片头长开关
        /// </summary>
        public bool NJPHeadLengthSwitch;
        /// <summary>
        /// 负极极片头长最小值
        /// </summary>
        public double NJPHeadLengthMin;
        /// <summary>
        /// 负极极片头长最大值
        /// </summary>
        public double NJPHeadLengthMax;
        /// <summary>
        /// 负极极片头长标准值
        /// </summary>
        public double NJPHeadLengthStandard;
        /// <summary>
        /// 负极极片头长自定义命名
        /// </summary>
        public string NJPHeadLengthName = "极片头长";
        /// <summary>
        /// 负极极片头长补偿值
        /// </summary>
        public double NJPHeadLengthCompensate;
        /// <summary>
        /// 负极极片头长工艺范围
        /// </summary>
        public string NJPHeadLengthRange;

        /// <summary>
        /// 负极极片尾长开关-开发者
        /// </summary>
        public bool NJPTailLengthSwitch_Developer;
        /// <summary>
        /// 负极极片尾长开关
        /// </summary>
        public bool NJPTailLengthSwitch;
        /// <summary>
        /// 负极极片尾长最小值
        /// </summary>
        public double NJPTailLengthMin;
        /// <summary>
        /// 负极极片尾长最大值
        /// </summary>
        public double NJPTailLengthMax;
        /// <summary>
        /// 负极极片尾长标准值
        /// </summary>
        public double NJPTailLengthStandard;
        /// <summary>
        /// 负极极片尾长自定义命名
        /// </summary>
        public string NJPTailLengthName = "极片尾长";
        /// <summary>
        /// 负极极片尾长补偿值
        /// </summary>
        public double NJPTailLengthCompensate;
        /// <summary>
        /// 负极极片尾长工艺范围
        /// </summary>
        public string NJPTailLengthRange;

        /// <summary>
        /// 负极左肩宽开关-开发者
        /// </summary>
        public bool NJELeftShoulderSwitch_Developer;
        /// <summary>
        /// 负极左肩宽开关
        /// </summary>
        public bool NJELeftShoulderSwitch;
        /// <summary>
        /// 负极左肩宽最小值
        /// </summary>
        public double NJELeftShoulderMin;
        /// <summary>
        /// 负极左肩宽最大值
        /// </summary>
        public double NJELeftShoulderMax;
        /// <summary>
        /// 负极左肩宽标准值
        /// </summary>
        public double NJELeftShoulderStandard;
        /// <summary>
        /// 负极左肩宽自定义命名
        /// </summary>
        public string NJELeftShoulderName = "左肩宽";
        /// <summary>
        /// 负极左肩宽补偿值
        /// </summary>
        public double NJELeftShoulderCompensate;
        /// <summary>
        /// 负极左肩宽工艺范围
        /// </summary>
        public string NJELeftShoulderRange;

        /// <summary>
        /// 负极右肩宽开关-开发者
        /// </summary>
        public bool NJERightShoulderSwitch_Developer;
        /// <summary>
        /// 负极右肩宽开关
        /// </summary>
        public bool NJERightShoulderSwitch;
        /// <summary>
        /// 负极右肩宽最小值
        /// </summary>
        public double NJERightShoulderMin;
        /// <summary>
        /// 负极右肩宽最大值
        /// </summary>
        public double NJERightShoulderMax;
        /// <summary>
        /// 负极右肩宽标准值
        /// </summary>
        public double NJERightShoulderStandard;
        /// <summary>
        /// 负极右肩宽自定义命名
        /// </summary>
        public string NJERightShoulderName = "右肩宽";
        /// <summary>
        /// 负极右肩宽补偿值
        /// </summary>
        public double NJERightShoulderCompensate;
        /// <summary>
        /// 负极右肩宽工艺范围
        /// </summary>
        public string NJERightShoulderRange;

        /// <summary>
        /// 负极极耳宽开关-开发者
        /// </summary>
        public bool NJEWidthSwitch_Developer;
        /// <summary>
        /// 负极极耳宽开关
        /// </summary>
        public bool NJEWidthSwitch;
        /// <summary>
        /// 负极极耳宽最小值
        /// </summary>
        public double NJEWidthMin;
        /// <summary>
        /// 负极极耳宽最大值
        /// </summary>
        public double NJEWidthMax;
        /// <summary>
        /// 负极极耳宽标准值
        /// </summary>
        public double NJEWidthStandard;
        /// <summary>
        /// 负极极耳宽自定义命名
        /// </summary>
        public string NJEWidthName = "极耳宽";
        /// <summary>
        /// 负极极耳宽补偿值
        /// </summary>
        public double NJEWidthCompensate;
        /// <summary>
        /// 负极极耳宽工艺范围
        /// </summary>
        public string NJEWidthRange;

        /// <summary>
        /// 负极极耳高开关-开发者
        /// </summary>
        public bool NJEHeightSwitch_Developer;
        /// <summary>
        /// 负极极耳高开关
        /// </summary>
        public bool NJEHeightSwitch;
        /// <summary>
        /// 负极极耳高最小值
        /// </summary>
        public double NJEHeightMin;
        /// <summary>
        /// 负极极耳高最大值
        /// </summary>
        public double NJEHeightMax;
        /// <summary>
        /// 负极极耳高标准值
        /// </summary>
        public double NJEHeightStandard;
        /// <summary>
        /// 负极极耳高自定义命名
        /// </summary>
        public string NJEHeightName = "极耳高";
        /// <summary>
        /// 负极极耳高补偿值
        /// </summary>
        public double NJEHeightCompensate;
        /// <summary>
        /// 负极极耳高工艺范围
        /// </summary>
        public string NJEHeightRange;

        /// <summary>
        /// 负极带料高开关-开发者
        /// </summary>
        public bool NDLHeightSwitch_Developer;
        /// <summary>
        /// 负极带料高开关
        /// </summary>
        public bool NDLHeightSwitch;
        /// <summary>
        /// 负极带料高最小值
        /// </summary>
        public double NDLHeightMin;
        /// <summary>
        /// 负极带料高最大值
        /// </summary>
        public double NDLHeightMax;
        /// <summary>
        /// 负极带料高标准值
        /// </summary>
        public double NDLHeightStandard;
        /// <summary>
        /// 负极带料高自定义命名
        /// </summary>
        public string NDLHeightName = "带料高";
        /// <summary>
        /// 负极带料高补偿值
        /// </summary>
        public double NDLHeightCompensate;
        /// <summary>
        /// 负极带料高工艺范围
        /// </summary>
        public string NDLHeightRange;

        /// <summary>
        /// 负极极片总宽开关-开发者
        /// </summary>
        public bool NJPTotalWidthSwitch_Developer;
        /// <summary>
        /// 负极极片总宽开关
        /// </summary>
        public bool NJPTotalWidthSwitch;
        /// <summary>
        /// 负极极片总宽最小值
        /// </summary>
        public double NJPTotalWidthMin;
        /// <summary>
        /// 负极极片总宽最大值
        /// </summary>
        public double NJPTotalWidthMax;
        /// <summary>
        /// 负极极片总宽标准值
        /// </summary>
        public double NJPTotalWidthStandard;
        /// <summary>
        /// 负极极片总宽自定义命名
        /// </summary>
        public string NJPTotalWidthName = "极片总宽";
        /// <summary>
        /// 负极极片总宽补偿值
        /// </summary>
        public double NJPTotalWidthCompensate;
        /// <summary>
        /// 负极极片总宽工艺范围
        /// </summary>
        public string NJPTotalWidthRange;

        /// <summary>
        /// 负极涂布高开关-开发者
        /// </summary>
        public bool NJPCoatingSwitch_Developer;
        /// <summary>
        /// 负极涂布高开关
        /// </summary>
        public bool NJPCoatingSwitch;
        /// <summary>
        /// 负极涂布高最小值
        /// </summary>
        public double NJPCoatingMin;
        /// <summary>
        /// 负极涂布高最大值
        /// </summary>
        public double NJPCoatingMax;
        /// <summary>
        /// 负极涂布高标准值
        /// </summary>
        public double NJPCoatingStandard;
        /// <summary>
        /// 负极涂布高自定义命名
        /// </summary>
        public string NJPCoatingName = "涂布高";
        /// <summary>
        /// 负极涂布高补偿值
        /// </summary>
        public double NJPCoatingCompensate;
        /// <summary>
        /// 负极涂布高工艺范围
        /// </summary>
        public string NJPCoatingRange;

        /// <summary>
        /// 负极对角线开关-开发者
        /// </summary>
        public bool NDiagonalSwitch_Developer;
        /// <summary>
        /// 负极对角线开关
        /// </summary>
        public bool NDiagonalSwitch;
        /// <summary>
        /// 负极对角线最小值
        /// </summary>
        public double NDiagonalMin;
        /// <summary>
        /// 负极对角线最大值
        /// </summary>
        public double NDiagonalMax;
        /// <summary>
        /// 负极对角线标准值
        /// </summary>
        public double NDiagonalStandard;
        /// <summary>
        /// 负极对角线自定义命名
        /// </summary>
        public string NDiagonalName = "对角线";
        /// <summary>
        /// 负极对角线补偿值
        /// </summary>
        public double NDiagonalCompensate;
        /// <summary>
        /// 负极对角线工艺范围
        /// </summary>
        public string NDiagonalRange;

        /// <summary>
        /// 负极左上角度开关-开发者
        /// </summary>
        public bool NLeftUpAngleSwitch_Developer;
        /// <summary>
        /// 负极左上角度开关
        /// </summary>
        public bool NLeftUpAngleSwitch;
        /// <summary>
        /// 负极左上角度最小值
        /// </summary>
        public double NLeftUpAngleMin;
        /// <summary>
        /// 负极左上角度最大值
        /// </summary>
        public double NLeftUpAngleMax;
        /// <summary>
        /// 负极左上角度标准值
        /// </summary>
        public double NLeftUpAngleStandard;
        /// <summary>
        /// 负极左上角度自定义命名
        /// </summary>
        public string NLeftUpAngleName = "左上角度";
        /// <summary>
        /// 负极左上角度补偿值
        /// </summary>
        public double NLeftUpAngleCompensate;
        /// <summary>
        /// 负极左上角度工艺范围
        /// </summary>
        public string NLeftUpAngleRange;

        /// <summary>
        /// 负极右上角度开关-开发者
        /// </summary>
        public bool NRightUpAngleSwitch_Developer;
        /// <summary>
        /// 负极右上角度开关
        /// </summary>
        public bool NRightUpAngleSwitch;
        /// <summary>
        /// 负极右上角度最小值
        /// </summary>
        public double NRightUpAngleMin;
        /// <summary>
        /// 负极右上角度最大值
        /// </summary>
        public double NRightUpAngleMax;
        /// <summary>
        /// 负极右上角度标准值
        /// </summary>
        public double NRightUpAngleStandard;
        /// <summary>
        /// 负极右上角度自定义命名
        /// </summary>
        public string NRightUpAngleName = "右上角度";
        /// <summary>
        /// 负极右上角度补偿值
        /// </summary>
        public double NRightUpAngleCompensate;
        /// <summary>
        /// 负极右上角度工艺范围
        /// </summary>
        public string NRightUpAngleRange;

        /// <summary>
        /// 负极左下角度开关-开发者
        /// </summary>
        public bool NLeftDownAngleSwitch_Developer;
        /// <summary>
        /// 负极左下角度开关
        /// </summary>
        public bool NLeftDownAngleSwitch;
        /// <summary>
        /// 负极左下角度最小值
        /// </summary>
        public double NLeftDownAngleMin;
        /// <summary>
        /// 负极左下角度最大值
        /// </summary>
        public double NLeftDownAngleMax;
        /// <summary>
        /// 负极左下角度标准值
        /// </summary>
        public double NLeftDownAngleStandard;
        /// <summary>
        /// 负极左下角度自定义命名
        /// </summary>
        public string NLeftDownAngleName = "左下角度";
        /// <summary>
        /// 负极左下角度补偿值
        /// </summary>
        public double NLeftDownAngleCompensate;
        /// <summary>
        /// 负极左下角度工艺范围
        /// </summary>
        public string NLeftDownAngleRange;

        /// <summary>
        /// 负极右下角度开关-开发者
        /// </summary>
        public bool NRightDownAngleSwitch_Developer;
        /// <summary>
        /// 负极右下角度开关
        /// </summary>
        public bool NRightDownAngleSwitch;
        /// <summary>
        /// 负极右下角度最小值
        /// </summary>
        public double NRightDownAngleMin;
        /// <summary>
        /// 负极右下角度最大值
        /// </summary>
        public double NRightDownAngleMax;
        /// <summary>
        /// 负极右下角度标准值
        /// </summary>
        public double NRightDownAngleStandard;
        /// <summary>
        /// 负极右下角度自定义命名
        /// </summary>
        public string NRightDownAngleName = "右下角度";
        /// <summary>
        /// 负极右下角度补偿值
        /// </summary>
        public double NRightDownAngleCompensate;
        /// <summary>
        /// 负极右下角度工艺范围
        /// </summary>
        public string NRightDownAngleRange;


        /// <summary>
        /// 负极mark开关-开发者
        /// </summary>
        public bool NMarkSwitch_Developer;
        /// <summary>
        /// 负极mark开关
        /// </summary>
        public bool NMarkSwitch;
        /// <summary>
        /// 负极mark最小值
        /// </summary>
        public double NMarkMin;
        /// <summary>
        /// 负极mark最大值
        /// </summary>
        public double NMarkMax;



        #endregion

        #region 负极V角工艺

        #region 负极左上右上V角
        /// <summary>
        /// 负极V启用圆弧开关
        /// </summary>
        public bool NOpenArcSwitch;
        /// <summary>
        /// 负极左上圆弧角点灰度值
        /// </summary>
        public double NLeftUpArcjdGray;
        /// <summary>
        /// 负极左上圆弧半径
        /// </summary>
        public double NLeftUpArcRad;
        /// <summary>
        /// 负极左上圆弧角点与轮廓距离
        /// </summary>
        public double NLeftUpArcjdDit;



        /// <summary>
        /// 负极左上V角度开关-开发者
        /// </summary>
        public bool NLeftUpVAngleSwitch_Developer;
        /// <summary>
        /// 负极左上V角度开关
        /// </summary>
        public bool NLeftUpVAngleSwitch;
        /// <summary>
        /// 负极左上V角度最小值
        /// </summary>
        public double NLeftUpVAngleMin;
        /// <summary>
        /// 负极左上V角度最大值
        /// </summary>
        public double NLeftUpVAngleMax;
        /// <summary>
        /// 负极左上V角度标准值
        /// </summary>
        public double NLeftUpVAngleStandard;
        /// <summary>
        /// 负极左上V角度自定义命名
        /// </summary>
        public string NLeftUpVAngleName = "左上V角度";
        /// <summary>
        /// 负极左上V角度补偿值
        /// </summary>
        public double NLeftUpVAngleCompensate;
        /// <summary>
        /// 负极左上V角度工艺范围
        /// </summary>
        public string NLeftUpVAngleRange;




        /// <summary>
        /// 负极左上V宽度开关-开发者
        /// </summary>
        public bool NLeftUpVWidthSwitch_Developer;
        /// <summary>
        /// 负极左上V宽度开关
        /// </summary>
        public bool NLeftUpVWidthSwitch;
        /// <summary>
        /// 负极左上V宽度最小值
        /// </summary>
        public double NLeftUpVWidthMin;
        /// <summary>
        /// 负极左上V宽度最大值
        /// </summary>
        public double NLeftUpVWidthMax;
        /// <summary>
        /// 负极左上V宽度标准值
        /// </summary>
        public double NLeftUpVWidthStandard;
        /// <summary>
        /// 负极左上V宽度自定义命名
        /// </summary>
        public string NLeftUpVWidthName = "左上V宽度";
        /// <summary>
        /// 负极左上V宽度补偿值
        /// </summary>
        public double NLeftUpVWidthCompensate;
        /// <summary>
        /// 负极左上V宽度工艺范围
        /// </summary>
        public string NLeftUpVWidthRange;

        /// <summary>
        /// 负极左上V深度开关-开发者
        /// </summary>
        public bool NLeftUpVDepthSwitch_Developer;
        /// <summary>
        /// 负极左上V深度开关
        /// </summary>
        public bool NLeftUpVDepthSwitch;
        /// <summary>
        /// 负极左上V深度最小值
        /// </summary>
        public double NLeftUpVDepthMin;
        /// <summary>
        /// 负极左上V深度最大值
        /// </summary>
        public double NLeftUpVDepthMax;
        /// <summary>
        /// 负极左上V深度标准值
        /// </summary>
        public double NLeftUpVDepthStandard;
        /// <summary>
        /// 负极左上V深度自定义命名
        /// </summary>
        public string NLeftUpVDepthName = "左上V深度";
        /// <summary>
        /// 负极左上V深度补偿值
        /// </summary>
        public double NLeftUpVDepthCompensate;
        /// <summary>
        /// 负极左上V深度工艺范围
        /// </summary>
        public string NLeftUpVDepthRange;



        /// <summary>
        /// 负极右上圆弧角点灰度值
        /// </summary>
        public double NRightUpArcjdGray;
        /// <summary>
        /// 负极右上圆弧半径
        /// </summary>
        public double NRightUpArcRad;
        /// <summary>
        /// 负极右上圆弧角点与轮廓距离
        /// </summary>
        public double NRightUpArcjdDit;

        /// <summary>
        /// 负极右上V角度开关-开发者
        /// </summary>
        public bool NRightUpVAngleSwitch_Developer;
        /// <summary>
        /// 负极右上V角度开关
        /// </summary>
        public bool NRightUpVAngleSwitch;
        /// <summary>
        /// 负极右上V角度最小值
        /// </summary>
        public double NRightUpVAngleMin;
        /// <summary>
        /// 负极右上V角度最大值
        /// </summary>
        public double NRightUpVAngleMax;
        /// <summary>
        /// 负极右上V角度标准值
        /// </summary>
        public double NRightUpVAngleStandard;
        /// <summary>
        /// 负极右上V角度自定义命名
        /// </summary>
        public string NRightUpVAngleName = "右上V角度";
        /// <summary>
        /// 负极右上V角度补偿值
        /// </summary>
        public double NRightUpVAngleCompensate;
        /// <summary>
        /// 负极右上V角度工艺范围
        /// </summary>
        public string NRightUpVAngleRange;

        /// <summary>
        /// 负极右上V宽度开关-开发者
        /// </summary>
        public bool NRightUpVWidthSwitch_Developer;
        /// <summary>
        /// 负极右上V宽度开关
        /// </summary>
        public bool NRightUpVWidthSwitch;
        /// <summary>
        /// 负极右上V宽度最小值
        /// </summary>
        public double NRightUpVWidthMin;
        /// <summary>
        /// 负极右上V宽度最大值
        /// </summary>
        public double NRightUpVWidthMax;
        /// <summary>
        /// 负极右上V宽度标准值
        /// </summary>
        public double NRightUpVWidthStandard;
        /// <summary>
        /// 负极右上V宽度自定义命名
        /// </summary>
        public string NRightUpVWidthName = "右上V宽度";
        /// <summary>
        /// 负极右上V宽度补偿值
        /// </summary>
        public double NRightUpVWidthCompensate;
        /// <summary>
        /// 负极右上V宽度工艺范围
        /// </summary>
        public string NRightUpVWidthRange;

        /// <summary>
        /// 负极右上V深度开关-开发者
        /// </summary>
        public bool NRightUpVDepthSwitch_Developer;
        /// <summary>
        /// 负极右上V深度开关
        /// </summary>
        public bool NRightUpVDepthSwitch;
        /// <summary>
        /// 负极右上V深度最小值
        /// </summary>
        public double NRightUpVDepthMin;
        /// <summary>
        /// 负极右上V深度最大值
        /// </summary>
        public double NRightUpVDepthMax;
        /// <summary>
        /// 负极右上V深度标准值
        /// </summary>
        public double NRightUpVDepthStandard;
        /// <summary>
        /// 负极右上V深度自定义命名
        /// </summary>
        public string NRightUpVDepthName = "右上V深度";
        /// <summary>
        /// 负极右上V深度补偿值
        /// </summary>
        public double NRightUpVDepthCompensate;
        /// <summary>
        /// 负极右上V深度工艺范围
        /// </summary>
        public string NRightUpVDepthRange;
        #endregion

        #region 负极左下右下V角

        /// <summary>
        /// 负极左下圆弧角点灰度值
        /// </summary>
        public double NLeftDownArcjdGray;
        /// <summary>
        /// 负极左下圆弧半径
        /// </summary>
        public double NLeftDownArcRad;
        /// <summary>
        /// 负极左下圆弧角点与轮廓距离
        /// </summary>
        public double NLeftDownArcjdDit;

        /// <summary>
        /// 负极左下V角度开关-开发者
        /// </summary>
        public bool NLeftDownVAngleSwitch_Developer;
        /// <summary>
        /// 负极左下V角度开关
        /// </summary>
        public bool NLeftDownVAngleSwitch;
        /// <summary>
        /// 负极左下V角度最小值
        /// </summary>
        public double NLeftDownVAngleMin;
        /// <summary>
        /// 负极左下V角度最大值
        /// </summary>
        public double NLeftDownVAngleMax;
        /// <summary>
        /// 负极左下V角度标准值
        /// </summary>
        public double NLeftDownVAngleStandard;
        /// <summary>
        /// 负极左下V角度自定义命名
        /// </summary>
        public string NLeftDownVAngleName = "左下V角度";
        /// <summary>
        /// 负极左下V角度补偿值
        /// </summary>
        public double NLeftDownVAngleCompensate;
        /// <summary>
        /// 负极左下V角度工艺范围
        /// </summary>
        public string NLeftDownVAngleRange;

        /// <summary>
        /// 负极左下V宽度开关-开发者
        /// </summary>
        public bool NLeftDownVWidthSwitch_Developer;
        /// <summary>
        /// 负极左下V宽度开关
        /// </summary>
        public bool NLeftDownVWidthSwitch;
        /// <summary>
        /// 负极左下V宽度最小值
        /// </summary>
        public double NLeftDownVWidthMin;
        /// <summary>
        /// 负极左下V宽度最大值
        /// </summary>
        public double NLeftDownVWidthMax;
        /// <summary>
        /// 负极左下V宽度标准值
        /// </summary>
        public double NLeftDownVWidthStandard;
        /// <summary>
        /// 负极左下V宽度自定义命名
        /// </summary>
        public string NLeftDownVWidthName = "左下V宽度";
        /// <summary>
        /// 负极左下V宽度补偿值
        /// </summary>
        public double NLeftDownVWidthCompensate;
        /// <summary>
        /// 负极左下V宽度工艺范围
        /// </summary>
        public string NLeftDownVWidthRange;

        /// <summary>
        /// 负极左下V深度开关-开发者
        /// </summary>
        public bool NLeftDownVDepthSwitch_Developer;
        /// <summary>
        /// 负极左下V深度开关
        /// </summary>
        public bool NLeftDownVDepthSwitch;
        /// <summary>
        /// 负极左下V深度最小值
        /// </summary>
        public double NLeftDownVDepthMin;
        /// <summary>
        /// 负极左下V深度最大值
        /// </summary>
        public double NLeftDownVDepthMax;
        /// <summary>
        /// 负极左下V深度标准值
        /// </summary>
        public double NLeftDownVDepthStandard;
        /// <summary>
        /// 负极左下V深度自定义命名
        /// </summary>
        public string NLeftDownVDepthName = "左下V深度";
        /// <summary>
        /// 负极左下V深度补偿值
        /// </summary>
        public double NLeftDownVDepthCompensate;
        /// <summary>
        /// 负极左下V深度工艺范围
        /// </summary>
        public string NLeftDownVDepthRange;



        /// <summary>
        /// 负极右下圆弧角点灰度值
        /// </summary>
        public double NRightDownArcjdGray;
        /// <summary>
        /// 负极右下圆弧半径
        /// </summary>
        public double NRightDownArcRad;
        /// <summary>
        /// 负极右下圆弧角点与轮廓距离
        /// </summary>
        public double NRightDownArcjdDit;


        /// <summary>
        /// 负极右下V角度开关-开发者
        /// </summary>
        public bool NRightDownVAngleSwitch_Developer;
        /// <summary>
        /// 负极右下V角度开关
        /// </summary>
        public bool NRightDownVAngleSwitch;
        /// <summary>
        /// 负极右下V角度最小值
        /// </summary>
        public double NRightDownVAngleMin;
        /// <summary>
        /// 负极右下V角度最大值
        /// </summary>
        public double NRightDownVAngleMax;
        /// <summary>
        /// 负极右下V角度标准值
        /// </summary>
        public double NRightDownVAngleStandard;
        /// <summary>
        /// 负极右下V角度自定义命名
        /// </summary>
        public string NRightDownVAngleName = "右下V角度";
        /// <summary>
        /// 负极右下V角度补偿值
        /// </summary>
        public double NRightDownVAngleCompensate;
        /// <summary>
        /// 负极右下V角度工艺范围
        /// </summary>
        public string NRightDownVAngleRange;

        /// <summary>
        /// 负极右下V宽度开关-开发者
        /// </summary>
        public bool NRightDownVWidthSwitch_Developer;
        /// <summary>
        /// 负极右下V宽度开关
        /// </summary>
        public bool NRightDownVWidthSwitch;
        /// <summary>
        /// 负极右下V宽度最小值
        /// </summary>
        public double NRightDownVWidthMin;
        /// <summary>
        /// 负极右下V宽度最大值
        /// </summary>
        public double NRightDownVWidthMax;
        /// <summary>
        /// 负极右下V宽度标准值
        /// </summary>
        public double NRightDownVWidthStandard;
        /// <summary>
        /// 负极右下V宽度自定义命名
        /// </summary>
        public string NRightDownVWidthName = "右下V宽度";
        /// <summary>
        /// 负极右下V宽度补偿值
        /// </summary>
        public double NRightDownVWidthCompensate;
        /// <summary>
        /// 负极右下V宽度工艺范围
        /// </summary>
        public string NRightDownVWidthRange;

        /// <summary>
        /// 负极右下V深度开关-开发者
        /// </summary>
        public bool NRightDownVDepthSwitch_Developer;
        /// <summary>
        /// 负极右下V深度开关
        /// </summary>
        public bool NRightDownVDepthSwitch;
        /// <summary>
        /// 负极右下V深度最小值
        /// </summary>
        public double NRightDownVDepthMin;
        /// <summary>
        /// 负极右下V深度最大值
        /// </summary>
        public double NRightDownVDepthMax;
        /// <summary>
        /// 负极右下V深度标准值
        /// </summary>
        public double NRightDownVDepthStandard;
        /// <summary>
        /// 负极右下V深度自定义命名
        /// </summary>
        public string NRightDownVDepthName = "右下V深度";
        /// <summary>
        /// 负极右下V深度补偿值
        /// </summary>
        public double NRightDownVDepthCompensate;
        /// <summary>
        /// 负极右下V深度工艺范围
        /// </summary>
        public string NRightDownVDepthRange;

        #endregion

        #endregion

        #region 正极工艺
        /// <summary>
        /// 正极极片头宽开关-开发者
        /// </summary>
        public bool PJPHeadWidthSwitch_Developer;
        /// <summary>
        /// 正极极片头宽开关
        /// </summary>
        public bool PJPHeadWidthSwitch;
        /// <summary>
        /// 正极极片头宽最小值
        /// </summary>
        public double PJPHeadWidthMin;
        /// <summary>
        /// 正极极片头宽最大值
        /// </summary>
        public double PJPHeadWidthMax;
        /// <summary>
        /// 正极极片头宽标准值
        /// </summary>
        public double PJPHeadWidthStandard;
        /// <summary>
        /// 正极极片头宽自定义命名
        /// </summary>
        public string PJPHeadWidthName = "极片头宽";
        /// <summary>
        /// 正极极片头宽补偿值
        /// </summary>
        public double PJPHeadWidthCompensate;
        /// <summary>
        /// 正极极片头宽工艺范围
        /// </summary>
        public string PJPHeadWidthRange;


        /// <summary>
        /// 正极极片尾宽开关-开发者
        /// </summary>
        public bool PJPTailWidthSwitch_Developer;
        /// <summary>
        /// 正极极片尾宽开关
        /// </summary>
        public bool PJPTailWidthSwitch;
        /// <summary>
        /// 正极极片尾宽最小值
        /// </summary>
        public double PJPTailWidthMin;
        /// <summary>
        /// 正极极片尾宽最大值
        /// </summary>
        public double PJPTailWidthMax;
        /// <summary>
        /// 正极极片尾宽标准值
        /// </summary>
        public double PJPTailWidthStandard;
        /// <summary>
        /// 正极极片尾宽自定义命名
        /// </summary>
        public string PJPTailWidthName = "极片尾宽";
        /// <summary>
        /// 正极极片尾宽补偿值
        /// </summary>
        public double PJPTailWidthCompensate;
        /// <summary>
        /// 正极极片尾宽工艺范围
        /// </summary>
        public string PJPTailWidthRange;

        /// <summary>
        /// 正极极片头长开关-开发者
        /// </summary>
        public bool PJPHeadLengthSwitch_Developer;
        /// <summary>
        /// 正极极片头长开关
        /// </summary>
        public bool PJPHeadLengthSwitch;
        /// <summary>
        /// 正极极片头长最小值
        /// </summary>
        public double PJPHeadLengthMin;
        /// <summary>
        /// 正极极片头长最大值
        /// </summary>
        public double PJPHeadLengthMax;
        /// <summary>
        /// 正极极片头长标准值
        /// </summary>
        public double PJPHeadLengthStandard;
        /// <summary>
        /// 正极极片头长自定义命名
        /// </summary>
        public string PJPHeadLengthName = "极片头长";
        /// <summary>
        /// 正极极片头长补偿值
        /// </summary>
        public double PJPHeadLengthCompensate;
        /// <summary>
        /// 正极极片头长工艺范围
        /// </summary>
        public string PJPHeadLengthRange;

        /// <summary>
        /// 正极极片尾长开关-开发者
        /// </summary>
        public bool PJPTailLengthSwitch_Developer;
        /// <summary>
        /// 正极极片尾长开关
        /// </summary>
        public bool PJPTailLengthSwitch;
        /// <summary>
        /// 正极极片尾长最小值
        /// </summary>
        public double PJPTailLengthMin;
        /// <summary>
        /// 正极极片尾长最大值
        /// </summary>
        public double PJPTailLengthMax;
        /// <summary>
        /// 正极极片尾长标准值
        /// </summary>
        public double PJPTailLengthStandard;
        /// <summary>
        /// 正极极片尾长自定义命名
        /// </summary>
        public string PJPTailLengthName = "极片尾长";
        /// <summary>
        /// 正极极片尾长补偿值
        /// </summary>
        public double PJPTailLengthCompensate;
        /// <summary>
        /// 正极极片尾长工艺范围
        /// </summary>
        public string PJPTailLengthRange;

        /// <summary>
        /// 正极左肩宽开关-开发者
        /// </summary>
        public bool PJELeftShoulderSwitch_Developer;
        /// <summary>
        /// 正极左肩宽开关
        /// </summary>
        public bool PJELeftShoulderSwitch;
        /// <summary>
        /// 正极左肩宽最小值
        /// </summary>
        public double PJELeftShoulderMin;
        /// <summary>
        /// 正极左肩宽最大值
        /// </summary>
        public double PJELeftShoulderMax;
        /// <summary>
        /// 正极左肩宽标准值
        /// </summary>
        public double PJELeftShoulderStandard;
        /// <summary>
        /// 正极左肩宽自定义命名
        /// </summary>
        public string PJELeftShoulderName = "左肩宽";
        /// <summary>
        /// 正极左肩宽补偿值
        /// </summary>
        public double PJELeftShoulderCompensate;
        /// <summary>
        /// 正极左肩宽工艺范围
        /// </summary>
        public string PJELeftShoulderRange;

        /// <summary>
        /// 正极右肩宽开关-开发者
        /// </summary>
        public bool PJERightShoulderSwitch_Developer;
        /// <summary>
        /// 正极右肩宽开关
        /// </summary>
        public bool PJERightShoulderSwitch;
        /// <summary>
        /// 正极右肩宽最小值
        /// </summary>
        public double PJERightShoulderMin;
        /// <summary>
        /// 正极右肩宽最大值
        /// </summary>
        public double PJERightShoulderMax;
        /// <summary>
        /// 正极右肩宽标准值
        /// </summary>
        public double PJERightShoulderStandard;
        /// <summary>
        /// 正极右肩宽自定义命名
        /// </summary>
        public string PJERightShoulderName = "右肩宽";
        /// <summary>
        /// 正极右肩宽补偿值
        /// </summary>
        public double PJERightShoulderCompensate;
        /// <summary>
        /// 正极右肩宽工艺范围
        /// </summary>
        public string PJERightShoulderRange;

        /// <summary>
        /// 正极极耳宽开关-开发者
        /// </summary>
        public bool PJEWidthSwitch_Developer;
        /// <summary>
        /// 正极极耳宽开关
        /// </summary>
        public bool PJEWidthSwitch;
        /// <summary>
        /// 正极极耳宽最小值
        /// </summary>
        public double PJEWidthMin;
        /// <summary>
        /// 正极极耳宽最大值
        /// </summary>
        public double PJEWidthMax;
        /// <summary>
        /// 正极极耳宽标准值
        /// </summary>
        public double PJEWidthStandard;
        /// <summary>
        /// 正极极耳宽自定义命名
        /// </summary>
        public string PJEWidthName = "极耳宽";
        /// <summary>
        /// 正极极耳宽补偿值
        /// </summary>
        public double PJEWidthCompensate;
        /// <summary>
        /// 正极极耳宽工艺范围
        /// </summary>
        public string PJEWidthRange;

        /// <summary>
        /// 正极极耳高开关-开发者
        /// </summary>
        public bool PJEHeightSwitch_Developer;
        /// <summary>
        /// 正极极耳高开关
        /// </summary>
        public bool PJEHeightSwitch;
        /// <summary>
        /// 正极极耳高最小值
        /// </summary>
        public double PJEHeightMin;
        /// <summary>
        /// 正极极耳高最大值
        /// </summary>
        public double PJEHeightMax;
        /// <summary>
        /// 正极极耳高标准值
        /// </summary>
        public double PJEHeightStandard;
        /// <summary>
        /// 正极极耳高自定义命名
        /// </summary>
        public string PJEHeightName = "极耳高";
        /// <summary>
        /// 正极极耳高补偿值
        /// </summary>
        public double PJEHeightCompensate;
        /// <summary>
        /// 正极极耳高工艺范围
        /// </summary>
        public string PJEHeightRange;

        /// <summary>
        /// 正极陶瓷高开关-开发者
        /// </summary>
        public bool PCeramicHeightSwitch_Developer;
        /// <summary>
        /// 正极陶瓷高开关
        /// </summary>
        public bool PCeramicHeightSwitch;
        /// <summary>
        /// 正极陶瓷高最小值
        /// </summary>
        public double PCeramicHeightMin;
        /// <summary>
        /// 正极陶瓷高最大值
        /// </summary>
        public double PCeramicHeightMax;
        /// <summary>
        /// 正极陶瓷高标准值
        /// </summary>
        public double PCeramicHeightStandard;
        /// <summary>
        /// 正极陶瓷高自定义命名
        /// </summary>
        public string PCeramicHeightName = "陶瓷高";
        /// <summary>
        /// 正极陶瓷高补偿值
        /// </summary>
        public double PCeramicHeightCompensate;
        /// <summary>
        /// 正极陶瓷高工艺范围
        /// </summary>
        public string PCeramicHeightRange;

        /// <summary>
        /// 正极极片总宽开关-开发者
        /// </summary>
        public bool PJPTotalWidthSwitch_Developer;
        /// <summary>
        /// 正极极片总宽开关
        /// </summary>
        public bool PJPTotalWidthSwitch;
        /// <summary>
        /// 正极极片总宽最小值
        /// </summary>
        public double PJPTotalWidthMin;
        /// <summary>
        /// 正极极片总宽最大值
        /// </summary>
        public double PJPTotalWidthMax;
        /// <summary>
        /// 正极极片总宽标准值
        /// </summary>
        public double PJPTotalWidthStandard;
        /// <summary>
        /// 正极极片总宽自定义命名
        /// </summary>
        public string PJPTotalWidthName = "极片总宽";
        /// <summary>
        /// 正极极片总宽补偿值
        /// </summary>
        public double PJPTotalWidthCompensate;
        /// <summary>
        /// 正极极片总宽工艺范围
        /// </summary>
        public string PJPTotalWidthRange;

        /// <summary>
        /// 正极涂布高开关-开发者
        /// </summary>
        public bool PJPCoatingSwitch_Developer;
        /// <summary>
        /// 正极涂布高开关
        /// </summary>
        public bool PJPCoatingSwitch;
        /// <summary>
        /// 正极涂布高最小值
        /// </summary>
        public double PJPCoatingMin;
        /// <summary>
        /// 正极涂布高最大值
        /// </summary>
        public double PJPCoatingMax;
        /// <summary>
        /// 正极涂布高标准值
        /// </summary>
        public double PJPCoatingStandard;
        /// <summary>
        /// 正极涂布高自定义命名
        /// </summary>
        public string PJPCoatingName = "涂布高";
        /// <summary>
        /// 正极涂布高补偿值
        /// </summary>
        public double PJPCoatingCompensate;
        /// <summary>
        /// 正极涂布高工艺范围
        /// </summary>
        public string PJPCoatingRange;

        /// <summary>
        /// 正极对角线开关-开发者
        /// </summary>
        public bool PDiagonalSwitch_Developer;
        /// <summary>
        /// 正极对角线开关
        /// </summary>
        public bool PDiagonalSwitch;
        /// <summary>
        /// 正极对角线最小值
        /// </summary>
        public double PDiagonalMin;
        /// <summary>
        /// 正极对角线最大值
        /// </summary>
        public double PDiagonalMax;
        /// <summary>
        /// 正极对角线标准值
        /// </summary>
        public double PDiagonalStandard;
        /// <summary>
        /// 正极对角线自定义命名
        /// </summary>
        public string PDiagonalName = "对角线";
        /// <summary>
        /// 正极对角线补偿值
        /// </summary>
        public double PDiagonalCompensate;
        /// <summary>
        /// 正极对角线工艺范围
        /// </summary>
        public string PDiagonalRange;

        /// <summary>
        /// 正极左上角度开关-开发者
        /// </summary>
        public bool PLeftUpAngleSwitch_Developer;
        /// <summary>
        /// 正极左上角度开关
        /// </summary>
        public bool PLeftUpAngleSwitch;
        /// <summary>
        /// 正极左上角度最小值
        /// </summary>
        public double PLeftUpAngleMin;
        /// <summary>
        /// 正极左上角度最大值
        /// </summary>
        public double PLeftUpAngleMax;
        /// <summary>
        /// 正极左上角度标准值
        /// </summary>
        public double PLeftUpAngleStandard;
        /// <summary>
        /// 正极左上角度自定义命名
        /// </summary>
        public string PLeftUpAngleName = "左上角度";
        /// <summary>
        /// 正极左上角度补偿值
        /// </summary>
        public double PLeftUpAngleCompensate;
        /// <summary>
        /// 正极左上角度工艺范围
        /// </summary>
        public string PLeftUpAngleRange;

        /// <summary>
        /// 正极右上角度开关-开发者
        /// </summary>
        public bool PRightUpAngleSwitch_Developer;
        /// <summary>
        /// 正极右上角度开关
        /// </summary>
        public bool PRightUpAngleSwitch;
        /// <summary>
        /// 正极右上角度最小值
        /// </summary>
        public double PRightUpAngleMin;
        /// <summary>
        /// 正极右上角度最大值
        /// </summary>
        public double PRightUpAngleMax;
        /// <summary>
        /// 正极右上角度标准值
        /// </summary>
        public double PRightUpAngleStandard;
        /// <summary>
        /// 正极右上角度自定义命名
        /// </summary>
        public string PRightUpAngleName = "右上角度";
        /// <summary>
        /// 正极右上角度补偿值
        /// </summary>
        public double PRightUpAngleCompensate;
        /// <summary>
        /// 正极右上角度工艺范围
        /// </summary>
        public string PRightUpAngleRange;

        /// <summary>
        /// 正极左下角度开关-开发者
        /// </summary>
        public bool PLeftDownAngleSwitch_Developer;
        /// <summary>
        /// 正极左下角度开关
        /// </summary>
        public bool PLeftDownAngleSwitch;
        /// <summary>
        /// 正极左下角度最小值
        /// </summary>
        public double PLeftDownAngleMin;
        /// <summary>
        /// 正极左下角度最大值
        /// </summary>
        public double PLeftDownAngleMax;
        /// <summary>
        /// 正极左下角度标准值
        /// </summary>
        public double PLeftDownAngleStandard;
        /// <summary>
        /// 正极左下角度自定义命名
        /// </summary>
        public string PLeftDownAngleName = "左下角度";
        /// <summary>
        /// 正极左下角度补偿值
        /// </summary>
        public double PLeftDownAngleCompensate;
        /// <summary>
        /// 正极左下角度工艺范围
        /// </summary>
        public string PLeftDownAngleRange;

        /// <summary>
        /// 正极右下角度开关-开发者
        /// </summary>
        public bool PRightDownAngleSwitch_Developer;
        /// <summary>
        /// 正极右下角度开关
        /// </summary>
        public bool PRightDownAngleSwitch;
        /// <summary>
        /// 正极右下角度最小值
        /// </summary>
        public double PRightDownAngleMin;
        /// <summary>
        /// 正极右下角度最大值
        /// </summary>
        public double PRightDownAngleMax;
        /// <summary>
        /// 正极右下角度标准值
        /// </summary>
        public double PRightDownAngleStandard;
        /// <summary>
        /// 正极右下角度自定义命名
        /// </summary>
        public string PRightDownAngleName = "右下角度";
        /// <summary>
        /// 正极右下角度补偿值
        /// </summary>
        public double PRightDownAngleCompensate;
        /// <summary>
        /// 正极右下角度工艺范围
        /// </summary>
        public string PRightDownAngleRange;

        /// <summary>
        /// 正极mark开关-开发者
        /// </summary>
        public bool PMarkSwitch_Developer;
        /// <summary>
        /// 正极mark开关
        /// </summary>
        public bool PMarkSwitch;
        /// <summary>
        /// 正极mark最小值
        /// </summary>
        public double PMarkMin;
        /// <summary>
        /// 正极mark最大值
        /// </summary>
        public double PMarkMax;
        #endregion

        #region 正极V角工艺
        #region 正极左上右上V角

        /// <summary>
        /// 正极V启用圆弧开关
        /// </summary>
        public bool POpenArcSwitch;
        /// <summary>
        /// 正极左上圆弧角点灰度值
        /// </summary>
        public double PLeftUpArcjdGray;
        /// <summary>
        /// 正极左上圆弧半径
        /// </summary>
        public double PLeftUpArcRad;
        /// <summary>
        /// 正极左上圆弧角点与轮廓距离
        /// </summary>
        public double PLeftUpArcjdDit;

        /// <summary>
        /// 正极左上V角度开关-开发者
        /// </summary>
        public bool PLeftUpVAngleSwitch_Developer;
        /// <summary>
        /// 正极左上V角度开关
        /// </summary>
        public bool PLeftUpVAngleSwitch;
        /// <summary>
        /// 正极左上V角度最小值
        /// </summary>
        public double PLeftUpVAngleMin;
        /// <summary>
        /// 正极左上V角度最大值
        /// </summary>
        public double PLeftUpVAngleMax;
        /// <summary>
        /// 正极左上V角度标准值
        /// </summary>
        public double PLeftUpVAngleStandard;
        /// <summary>
        /// 正极左上V角度自定义命名
        /// </summary>
        public string PLeftUpVAngleName = "左上V角度";
        /// <summary>
        /// 正极左上V角度补偿值
        /// </summary>
        public double PLeftUpVAngleCompensate;
        /// <summary>
        /// 正极左上V角度工艺范围
        /// </summary>
        public string PLeftUpVAngleRange;

        /// <summary>
        /// 正极左上V宽度开关-开发者
        /// </summary>
        public bool PLeftUpVWidthSwitch_Developer;
        /// <summary>
        /// 正极左上V宽度开关
        /// </summary>
        public bool PLeftUpVWidthSwitch;
        /// <summary>
        /// 正极左上V宽度最小值
        /// </summary>
        public double PLeftUpVWidthMin;
        /// <summary>
        /// 正极左上V宽度最大值
        /// </summary>
        public double PLeftUpVWidthMax;
        /// <summary>
        /// 正极左上V宽度标准值
        /// </summary>
        public double PLeftUpVWidthStandard;
        /// <summary>
        /// 正极左上V宽度自定义命名
        /// </summary>
        public string PLeftUpVWidthName = "左上V宽度";
        /// <summary>
        /// 正极左上V宽度补偿值
        /// </summary>
        public double PLeftUpVWidthCompensate;
        /// <summary>
        /// 正极左上V宽度工艺范围
        /// </summary>
        public string PLeftUpVWidthRange;

        /// <summary>
        /// 正极左上V深度开关-开发者
        /// </summary>
        public bool PLeftUpVDepthSwitch_Developer;
        /// <summary>
        /// 正极左上V深度开关
        /// </summary>
        public bool PLeftUpVDepthSwitch;
        /// <summary>
        /// 正极左上V深度最小值
        /// </summary>
        public double PLeftUpVDepthMin;
        /// <summary>
        /// 正极左上V深度最大值
        /// </summary>
        public double PLeftUpVDepthMax;
        /// <summary>
        /// 正极左上V深度标准值
        /// </summary>
        public double PLeftUpVDepthStandard;
        /// <summary>
        /// 正极左上V深度自定义命名
        /// </summary>
        public string PLeftUpVDepthName = "左上V深度";
        /// <summary>
        /// 正极左上V深度补偿值
        /// </summary>
        public double PLeftUpVDepthCompensate;
        /// <summary>
        /// 正极左上V深度工艺范围
        /// </summary>
        public string PLeftUpVDepthRange;

        /// <summary>
        /// 正极右上圆弧角点灰度值
        /// </summary>
        public double PRightUpArcjdGray;
        /// <summary>
        /// 正极右上圆弧半径
        /// </summary>
        public double PRightUpArcRad;
        /// <summary>
        /// 正极右上圆弧角点与轮廓距离
        /// </summary>
        public double PRightUpArcjdDit;


        /// <summary>
        /// 正极右上V角度开关-开发者
        /// </summary>
        public bool PRightUpVAngleSwitch_Developer;
        /// <summary>
        /// 正极右上V角度开关
        /// </summary>
        public bool PRightUpVAngleSwitch;
        /// <summary>
        /// 正极右上V角度最小值
        /// </summary>
        public double PRightUpVAngleMin;
        /// <summary>
        /// 正极右上V角度最大值
        /// </summary>
        public double PRightUpVAngleMax;
        /// <summary>
        /// 正极右上V角度标准值
        /// </summary>
        public double PRightUpVAngleStandard;
        /// <summary>
        /// 负极右上V角度自定义命名
        /// </summary>
        public string PRightUpVAngleName = "右上V角度";
        /// <summary>
        /// 正极右上V角度补偿值
        /// </summary>
        public double PRightUpVAngleCompensate;
        /// <summary>
        /// 正极右上V角度工艺范围
        /// </summary>
        public string PRightUpVAngleRange;

        /// <summary>
        /// 正极右上V宽度开关-开发者
        /// </summary>
        public bool PRightUpVWidthSwitch_Developer;
        /// <summary>
        /// 正极右上V宽度开关
        /// </summary>
        public bool PRightUpVWidthSwitch;
        /// <summary>
        /// 正极右上V宽度最小值
        /// </summary>
        public double PRightUpVWidthMin;
        /// <summary>
        /// 正极右上V宽度最大值
        /// </summary>
        public double PRightUpVWidthMax;
        /// <summary>
        /// 正极右上V宽度标准值
        /// </summary>
        public double PRightUpVWidthStandard;
        /// <summary>
        /// 正极右上V宽度自定义命名
        /// </summary>
        public string PRightUpVWidthName = "右上V宽度";
        /// <summary>
        /// 正极右上V宽度补偿值
        /// </summary>
        public double PRightUpVWidthCompensate;
        /// <summary>
        /// 正极右上V宽度工艺范围
        /// </summary>
        public string PRightUpVWidthRange;

        /// <summary>
        /// 正极右上V深度开关-开发者
        /// </summary>
        public bool PRightUpVDepthSwitch_Developer;
        /// <summary>
        /// 正极右上V深度开关
        /// </summary>
        public bool PRightUpVDepthSwitch;
        /// <summary>
        /// 正极右上V深度最小值
        /// </summary>
        public double PRightUpVDepthMin;
        /// <summary>
        /// 正极右上V深度最大值
        /// </summary>
        public double PRightUpVDepthMax;
        /// <summary>
        /// 正极右上V深度标准值
        /// </summary>
        public double PRightUpVDepthStandard;
        /// <summary>
        /// 正极右上V深度自定义命名
        /// </summary>
        public string PRightUpVDepthName = "右上V深度";
        /// <summary>
        /// 正极右上V深度补偿值
        /// </summary>
        public double PRightUpVDepthCompensate;
        /// <summary>
        /// 正极右上V深度工艺范围
        /// </summary>
        public string PRightUpVDepthRange;

        #endregion
        #region 正极左下右下V角

        /// <summary>
        /// 正极左下圆弧角点灰度值
        /// </summary>
        public double PLeftDownArcjdGray;
        /// <summary>
        /// 正极左下圆弧半径
        /// </summary>
        public double PLeftDownArcRad;
        /// <summary>
        /// 正极左下圆弧角点与轮廓距离
        /// </summary>
        public double PLeftDownArcjdDit;

        /// <summary>
        /// 正极左下V角度开关
        /// </summary>
        public bool PLeftDownVAngleSwitch_Developer;
        /// <summary>
        /// 正极左下V角度开关
        /// </summary>
        public bool PLeftDownVAngleSwitch;
        /// <summary>
        /// 正极左下V角度最小值
        /// </summary>
        public double PLeftDownVAngleMin;
        /// <summary>
        /// 正极左下V角度最大值
        /// </summary>
        public double PLeftDownVAngleMax;
        /// <summary>
        /// 正极左下V角度标准值
        /// </summary>
        public double PLeftDownVAngleStandard;
        /// <summary>
        /// 正极左下V角度自定义命名
        /// </summary>
        public string PLeftDownVAngleName = "左下V角度";
        /// <summary>
        /// 正极左下V角度补偿值
        /// </summary>
        public double PLeftDownVAngleCompensate;
        /// <summary>
        /// 正极左下V角度工艺范围
        /// </summary>
        public string PLeftDownVAngleRange;

        /// <summary>
        /// 正极左下V宽度开关-开发者
        /// </summary>
        public bool PLeftDownVWidthSwitch_Developer;
        /// <summary>
        /// 正极左下V宽度开关
        /// </summary>
        public bool PLeftDownVWidthSwitch;
        /// <summary>
        /// 正极左下V宽度最小值
        /// </summary>
        public double PLeftDownVWidthMin;
        /// <summary>
        /// 正极左下V宽度最大值
        /// </summary>
        public double PLeftDownVWidthMax;
        /// <summary>
        /// 正极左下V宽度标准值
        /// </summary>
        public double PLeftDownVWidthStandard;
        /// <summary>
        /// 正极左下V宽度自定义命名
        /// </summary>
        public string PLeftDownVWidthName = "左下V宽度";
        /// <summary>
        /// 正极左下V宽度补偿值
        /// </summary>
        public double PLeftDownVWidthCompensate;
        /// <summary>
        /// 正极左下V宽度工艺范围
        /// </summary>
        public string PLeftDownVWidthRange;

        /// <summary>
        /// 正极左下V深度开关-开发者
        /// </summary>
        public bool PLeftDownVDepthSwitch_Developer;
        /// <summary>
        /// 正极左下V深度开关
        /// </summary>
        public bool PLeftDownVDepthSwitch;
        /// <summary>
        /// 正极左下V深度最小值
        /// </summary>
        public double PLeftDownVDepthMin;
        /// <summary>
        /// 正极左下V深度最大值
        /// </summary>
        public double PLeftDownVDepthMax;
        /// <summary>
        /// 正极左下V深度标准值
        /// </summary>
        public double PLeftDownVDepthStandard;
        /// <summary>
        /// 正极左下V深度自定义命名
        /// </summary>
        public string PLeftDownVDepthName = "左下V深度";
        /// <summary>
        /// 正极左下V深度补偿值
        /// </summary>
        public double PLeftDownVDepthCompensate;
        /// <summary>
        /// 正极左下V深度工艺范围
        /// </summary>
        public string PLeftDownVDepthRange;


        /// <summary>
        /// 正极右下圆弧角点灰度值
        /// </summary>
        public double PRightDownArcjdGray;
        /// <summary>
        /// 正极右下圆弧半径
        /// </summary>
        public double PRightDownArcRad;
        /// <summary>
        /// 正极右下圆弧角点与轮廓距离
        /// </summary>
        public double PRightDownArcjdDit;

        /// <summary>
        /// 正极右下V角度开关-开发者
        /// </summary>
        public bool PRightDownVAngleSwitch_Developer;
        /// <summary>
        /// 正极右下V角度开关
        /// </summary>
        public bool PRightDownVAngleSwitch;
        /// <summary>
        /// 正极右下V角度最小值
        /// </summary>
        public double PRightDownVAngleMin;
        /// <summary>
        /// 正极右下V角度最大值
        /// </summary>
        public double PRightDownVAngleMax;
        /// <summary>
        /// 正极右下V角度标准值
        /// </summary>
        public double PRightDownVAngleStandard;
        /// <summary>
        /// 正极右下V角度自定义命名
        /// </summary>
        public string PRightDownVAngleName = "右下V角度";
        /// <summary>
        /// 正极右下V角度补偿值
        /// </summary>
        public double PRightDownVAngleCompensate;
        /// <summary>
        /// 正极右下V角度工艺范围
        /// </summary>
        public string PRightDownVAngleRange;

        /// <summary>
        /// 正极右下V宽度开关-开发者
        /// </summary>
        public bool PRightDownVWidthSwitch_Developer;
        /// <summary>
        /// 正极右下V宽度开关
        /// </summary>
        public bool PRightDownVWidthSwitch;
        /// <summary>
        /// 正极右下V宽度最小值
        /// </summary>
        public double PRightDownVWidthMin;
        /// <summary>
        /// 正极右下V宽度最大值
        /// </summary>
        public double PRightDownVWidthMax;
        /// <summary>
        /// 正极右下V宽度标准值
        /// </summary>
        public double PRightDownVWidthStandard;
        /// <summary>
        /// 正极右下V宽度自定义命名
        /// </summary>
        public string PRightDownVWidthName = "右下V宽度";
        /// <summary>
        /// 正极右下V宽度补偿值
        /// </summary>
        public double PRightDownVWidthCompensate;
        /// <summary>
        /// 正极右下V宽度工艺范围
        /// </summary>
        public string PRightDownVWidthRange;

        /// <summary>
        /// 正极右下V深度开关-开发者
        /// </summary>
        public bool PRightDownVDepthSwitch_Developer;
        /// <summary>
        /// 正极右下V深度开关
        /// </summary>
        public bool PRightDownVDepthSwitch;
        /// <summary>
        /// 正极右下V深度最小值
        /// </summary>
        public double PRightDownVDepthMin;
        /// <summary>
        /// 正极右下V深度最大值
        /// </summary>
        public double PRightDownVDepthMax;
        /// <summary>
        /// 正极右下V深度标准值
        /// </summary>
        public double PRightDownVDepthStandard;
        /// <summary>
        /// 正极右下V深度自定义命名
        /// </summary>
        public string PRightDownVDepthName = "右下V深度";
        /// <summary>
        /// 正极右下V深度补偿值
        /// </summary>
        public double PRightDownVDepthCompensate;
        /// <summary>
        /// 正极右下V深度工艺范围
        /// </summary>
        public string PRightDownVDepthRange;

        #endregion

        #endregion

        #region 极耳打折工艺

        #region 负极极耳打折工艺
        /// <summary>
        /// 负极极耳打折开关-开发者
        /// </summary>
        public bool NJEBevelLimitSwitch_Developer;
        /// <summary>
        /// 负极极耳打折开关
        /// </summary>
        public bool NJEBevelLimitSwitch;
        /// <summary>
        /// 负极极耳打折开关1
        /// </summary>
        public bool NJEBevelLimitSwitch1;
        /// <summary>
        /// 负极极耳所在位置
        /// </summary>
        public string NJELocation = "左下";
        /// <summary>
        /// 负极极耳所在位置1 极耳双相机时使用
        /// </summary>
        public string NJELocation1 = "右下";
        /// <summary>
        /// 负极极耳打折最小灰度值
        /// </summary>
        public int NJEGrayMin;
        /// <summary>
        /// 负极极耳打折最大灰度值
        /// </summary>
        public int NJEGrayMax;
        /// <summary>
        /// 负极极耳打折最小灰度值1
        /// </summary>
        public int NJEGrayMin1;
        /// <summary>
        /// 负极极耳打折最大灰度值1
        /// </summary>
        public int NJEGrayMax1;

        /// <summary>
        /// 负极极耳打折标准面积
        /// </summary>
        public double NJEAreaStandard;
        /// <summary>
        /// 负极极耳打折面积容差
        /// </summary>
        public double NJEAreaRange;
        /// <summary>
        /// 负极极耳打折余料面积
        /// </summary>
        public double NJeOddmentsArea;
        /// <summary>
        /// 负极极耳打折标准面积1
        /// </summary>
        public double NJEAreaStandard1;
        /// <summary>
        /// 负极极耳打折面积容差1
        /// </summary>
        public double NJEAreaRange1;
        /// <summary>
        /// 负极极耳打折余料面积1
        /// </summary>
        public double NJeOddmentsArea1;

        /// <summary>
        /// 负极极耳打折框上下偏移
        /// </summary>
        public double NJERowSkew;
        /// <summary>
        /// 负极极耳打折框左右偏移
        /// </summary>
        public double NJEColumnSkew;
        /// <summary>
        /// 负极极耳打折框上下偏移1-极耳双相机时使用
        /// </summary>
        public double NJERowSkew1;
        /// <summary>
        /// 负极极耳打折框左右偏移1-极耳双相机时使用
        /// </summary>
        public double NJEColumnSkew1;
        /// <summary>
        /// 负极极耳打折X内缩
        /// </summary>
        public double NJEColumnErosion;
        /// <summary>
        /// 负极极耳打折Y内缩
        /// </summary>
        public double NJERowErosion;
        /// <summary>
        /// 负极极耳打折矩形相似度
        /// </summary>
        public double NJERectangularity;
        /// <summary>
        /// 负极极耳打折X内缩1
        /// </summary>
        public double NJEColumnErosion1;
        /// <summary>
        /// 负极极耳打折Y内缩1
        /// </summary>
        public double NJERowErosion1;
        /// <summary>
        /// 负极极耳打折矩形相似度1
        /// </summary>
        public double NJERectangularity1;


        /// <summary>
        /// 负极极耳打折缺口最小灰度值
        /// </summary>
        public double NJEGapGrayMin;
        /// <summary>
        /// 负极极耳打折缺口最大灰度值
        /// </summary>
        public double NJEGapGrayMax;
        /// <summary>
        /// 负极极耳打折缺口面积上限
        /// </summary>
        public double NJEGapAreaMax;
        /// <summary>
        /// 负极极耳打折缺口最小灰度值1
        /// </summary>
        public double NJEGapGrayMin1;
        /// <summary>
        /// 负极极耳打折缺口最大灰度值1
        /// </summary>
        public double NJEGapGrayMax1;
        /// <summary>
        /// 负极极耳打折缺口面积上限1
        /// </summary>
        public double NJEGapAreaMax1;


        /// <summary>
        /// 负极极耳打折高度
        /// </summary>
        public double NJEHeight;
        /// <summary>
        /// 负极极耳打折宽度
        /// </summary>
        public double NJEWidth;
        /// <summary>
        /// 负极极耳打折高度1-极耳双相机时使用
        /// </summary>
        public double NJEHeight1;
        /// <summary>
        /// 负极极耳打折宽度1-极耳双相机时使用
        /// </summary>
        public double NJEWidth1;
        /// <summary>
        /// 负极极耳上圆弧灰度值
        /// </summary>
        public double NArcGrayMin_Up;
        /// <summary>
        /// 负极极耳上圆弧面积上限
        /// </summary>
        public double NArcAreaMax_Up;
        /// <summary>
        /// 负极极耳下圆弧面积上限
        /// </summary>
        public double NArcAreaMax_Down;
        /// <summary>
        /// 负极极耳下圆弧面积下限
        /// </summary>
        public double NArcAreaMin_Down;

        /// <summary>
        /// 负极极耳上圆弧灰度值1
        /// </summary>
        public double NArcGrayMin_Up1;
        /// <summary>
        /// 负极极耳上圆弧面积上限1
        /// </summary>
        public double NArcAreaMax_Up1;
        /// <summary>
        /// 负极极耳下圆弧面积上限1
        /// </summary>
        public double NArcAreaMax_Down1;
        /// <summary>
        /// 负极极耳下圆弧面积下限1
        /// </summary>
        public double NArcAreaMin_Down1;

        #endregion 

        #region 正极极耳打折工艺

        /// <summary>
        /// 正极极耳打折开关-开发者
        /// </summary>
        public bool PJEBevelLimitSwitch_Developer;
        /// <summary>
        /// 正极极耳打折开关
        /// </summary>
        public bool PJEBevelLimitSwitch;
        /// <summary>
        /// 正极极耳打折开关1
        /// </summary>
        public bool PJEBevelLimitSwitch1;
        /// <summary>
        /// 正极极耳所在位置
        /// </summary>
        public string PJELocation = "左下";
        /// <summary>
        /// 正极极耳所在位置1  极耳双相机时使用
        /// </summary>
        public string PJELocation1 = "右下";
        /// <summary>
        /// 正极极耳打折最小灰度值
        /// </summary>
        public int PJEGrayMin;
        /// <summary>
        /// 正极极耳打折最大灰度值
        /// </summary>
        public int PJEGrayMax;
        /// <summary>
        /// 正极极耳打折标准面积
        /// </summary>
        public double PJEAreaStandard;
        /// <summary>
        /// 正极极耳打折面积容差
        /// </summary>
        public double PJEAreaRange;
        /// <summary>
        /// 正极极耳打折最小灰度值1
        /// </summary>
        public int PJEGrayMin1;
        /// <summary>
        /// 正极极耳打折最大灰度值1
        /// </summary>
        public int PJEGrayMax1;
        /// <summary>
        /// 正极极耳打折标准面积1
        /// </summary>
        public double PJEAreaStandard1;
        /// <summary>
        /// 正极极耳打折面积容差1
        /// </summary>
        public double PJEAreaRange1;


        /// <summary>
        /// 正极极耳打折余料面积
        /// </summary>
        public double PJeOddmentsArea;
        /// <summary>
        /// 正极极耳打折余料面积1
        /// </summary>
        public double PJeOddmentsArea1;
        /// <summary>
        /// 正极极耳打折框上下偏移
        /// </summary>
        public double PJERowSkew;
        /// <summary>
        /// 正极极耳打折框左右偏移
        /// </summary>
        public double PJEColumnSkew;
        /// <summary>
        /// 正极极耳打折框上下偏移1-极耳双相机使用
        /// </summary>
        public double PJERowSkew1;
        /// <summary>
        /// 正极极耳打折框左右偏移1-极耳双相机使用
        /// </summary>
        public double PJEColumnSkew1;
        /// <summary>
        /// 正极极耳打折X内缩
        /// </summary>
        public double PJEColumnErosion;
        /// <summary>
        /// 正极极耳打折Y内缩
        /// </summary>
        public double PJERowErosion;
        /// <summary>
        /// 正极极耳打折矩形相似度
        /// </summary>
        public double PJERectangularity;
        /// <summary>
        /// 正极极耳打折X内缩1
        /// </summary>
        public double PJEColumnErosion1;
        /// <summary>
        /// 正极极耳打折Y内缩1
        /// </summary>
        public double PJERowErosion1;
        /// <summary>
        /// 正极极耳打折矩形相似度1
        /// </summary>
        public double PJERectangularity1;


        /// <summary>
        /// 正极极耳打折缺口最小灰度值
        /// </summary>
        public double PJEGapGrayMin;
        /// <summary>
        /// 正极极耳打折缺口最大灰度值
        /// </summary>
        public double PJEGapGrayMax;
        /// <summary>
        /// 正极极耳打折缺口面积上限
        /// </summary>
        public double PJEGapAreaMax;
        /// <summary>
        /// 正极极耳打折缺口最小灰度值1
        /// </summary>
        public double PJEGapGrayMin1;
        /// <summary>
        /// 正极极耳打折缺口最大灰度值1
        /// </summary>
        public double PJEGapGrayMax1;
        /// <summary>
        /// 正极极耳打折缺口面积上限1
        /// </summary>
        public double PJEGapAreaMax1;

        /// <summary>
        /// 正极极耳打折高度
        /// </summary>
        public double PJEHeight;
        /// <summary>
        /// 正极极耳打折宽度
        /// </summary>
        public double PJEWidth;
        /// <summary>
        /// 正极极耳打折高度1-极耳双相机时使用
        /// </summary>
        public double PJEHeight1;
        /// <summary>
        /// 正极极耳打折宽度1-极耳双相机时使用
        /// </summary>
        public double PJEWidth1;
        /// <summary>
        /// 正极极耳上圆弧面积上限
        /// </summary>
        public double PArcAreaMax_Up;
        /// <summary>
        /// 正极极耳下圆弧面积上限
        /// </summary>
        public double PArcAreaMax_Down;
        /// <summary>
        /// 正极极耳下圆弧面积下限
        /// </summary>
        public double PArcAreaMin_Down;
        /// <summary>
        /// 正极极耳上圆弧灰度值
        /// </summary>
        public double PArcGrayMin_Up;
        /// <summary>
        /// 正极极耳上圆弧面积上限1
        /// </summary>
        public double PArcAreaMax_Up1;
        /// <summary>
        /// 正极极耳下圆弧面积上限1
        /// </summary>
        public double PArcAreaMax_Down1;
        /// <summary>
        /// 正极极耳下圆弧面积下限1
        /// </summary>
        public double PArcAreaMin_Down1;
        /// <summary>
        /// 正极极耳上圆弧灰度值1
        /// </summary>
        public double PArcGrayMin_Up1;
        #endregion

        #endregion

        #region 缺角工艺

        /// <summary>
        /// 负极三角形开关
        /// </summary>
        public bool NBevelTriangleSwitch;

        /// <summary>
        /// 正极三角形开关
        /// </summary>
        public bool PBevelTriangleSwitch;


        #region 负极左上右上缺角工艺
        /// <summary>
        /// 负极左上缺角开关-开发者
        /// </summary>
        public bool NLeftUpBevelSwitch_Developer;
        /// <summary>
        /// 负极左上缺角开关
        /// </summary>
        public bool NLeftUpBevelSwitch;
        /// <summary>
        /// 负极左上缺角面积最小值
        /// </summary>
        public double NLeftUpBevelAreaMin;
        /// <summary>
        /// 负极左上缺角面积最大值
        /// </summary>
        public double NLeftUpBevelAreaMax;
        /// <summary>
        /// 负极左上缺角灰度值最小值
        /// </summary>
        public double NLeftUpBevelGrayMin;
        /// <summary>
        /// 负极左上缺角框大小
        /// </summary>
        public double NLeftUpBevelFrame;
        /// <summary>
        /// 负极左上缺角命名自定义
        /// </summary>
        public string NLeftUpBevelName = "左上缺角";
        /// <summary>
        /// 负极左上缺角面积补偿值
        /// </summary>
        public double NLeftUpBevelCompensate;

        /// <summary>
        /// 负极左上缺角Row偏移
        /// </summary>
        public double NLeftUpBevelRowSkew;
        /// <summary>
        /// 负极左上缺角col偏移
        /// </summary>
        public double NLeftUpBevelColSkew;
        /// <summary>
        /// 负极左上缺角工艺范围
        /// </summary>
        public string NLeftUpBevelRange;




        /// <summary>
        /// 负极右上缺角开关-开发者
        /// </summary>
        public bool NRightUpBevelSwitch_Developer;
        /// <summary>
        /// 负极右上缺角开关
        /// </summary>
        public bool NRightUpBevelSwitch;
        /// <summary>
        /// 负极右上缺角面积最大小值
        /// </summary>
        public double NRightUpBevelAreaMin;
        /// <summary>
        /// 负极右上缺角面积最大值
        /// </summary>
        public double NRightUpBevelAreaMax;
        /// <summary>
        /// 负极右上缺角灰度值最小值
        /// </summary>
        public int NRightUpBevelGrayMin;
        /// <summary>
        /// 负极右上缺角框大小
        /// </summary>
        public double NRightUpBevelFrame;
        /// <summary>
        /// 负极右上缺角命名自定义
        /// </summary>
        public string NRightUpBevelName = "右上缺角";
        /// <summary>
        /// 负极右上缺角面积补偿值
        /// </summary>
        public double NRightUpBevelCompensate;
        /// <summary>
        /// 负极右上缺角Row偏移
        /// </summary>
        public double NRightUpBevelRowSkew;
        /// <summary>
        /// 负极右上缺角col偏移
        /// </summary>
        public double NRightUpBevelColSkew;
        /// <summary>
        /// 负极右上缺角工艺范围
        /// </summary>
        public string NRightUpBevelRange;


        #endregion

        #region 负极左下右下缺角工艺
        /// <summary>
        /// 负极左下缺角开关-开发者
        /// </summary>
        public bool NLeftDownBevelSwitch_Developer;
        /// <summary>
        /// 负极左下缺角开关
        /// </summary>
        public bool NLeftDownBevelSwitch;
        /// <summary>
        /// 负极左下缺角面积最小值
        /// </summary>
        public double NLeftDownBevelAreaMin;
        /// <summary>
        /// 负极左下缺角面积最大值
        /// </summary>
        public double NLeftDownBevelAreaMax;
        /// <summary>
        /// 负极左下缺角灰度值最小值
        /// </summary>
        public int NLeftDownBevelGrayMin;
        /// <summary>
        /// 负极左下缺角框大小
        /// </summary>
        public double NLeftDownBevelFrame;
        /// <summary>
        /// 负极左下缺角命名自定义
        /// </summary>
        public string NLeftDownBevelName = "左下缺角";
        /// <summary>
        /// 负极左下缺角面积补偿值
        /// </summary>
        public double NLeftDownBevelCompensate;
        /// <summary>
        /// 负极左下缺角Row偏移
        /// </summary>
        public double NLeftDownBevelRowSkew;
        /// <summary>
        /// 负极左下缺角col偏移
        /// </summary>
        public double NLeftDownBevelColSkew;
        /// <summary>
        /// 负极左下缺角工艺范围
        /// </summary>
        public string NLeftDownBevelRange;


        /// <summary>
        /// 负极右下缺角开关-开发者
        /// </summary>
        public bool NRightDownBevelSwitch_Developer;
        /// <summary>
        /// 负极右下缺角开关
        /// </summary>
        public bool NRightDownBevelSwitch;
        /// <summary>
        /// 负极右下缺角面积最小值
        /// </summary>
        public double NRightDownBevelAreaMin;
        /// <summary>
        /// 负极右下缺角面积最大值
        /// </summary>
        public double NRightDownBevelAreaMax;
        /// <summary>
        /// 负极右下缺角灰度值最小值
        /// </summary>
        public int NRightDownBevelGrayMin;
        /// <summary>
        /// 负极右下缺角框大小
        /// </summary>
        public double NRightDownBevelFrame;
        /// <summary>
        /// 负极右下缺角命名自定义
        /// </summary>
        public string NRightDownBevelName = "右下缺角";
        /// <summary>
        /// 负极右下缺角面积补偿值
        /// </summary>
        public double NRightDownBevelCompensate;
        /// <summary>
        /// 负极右下缺角Row偏移
        /// </summary>
        public double NRightDownBevelRowSkew;
        /// <summary>
        /// 负极右下缺角col偏移
        /// </summary>
        public double NRightDownBevelColSkew;
        /// <summary>
        /// 负极右下缺角工艺范围
        /// </summary>
        public string NRightDownBevelRange;
        #endregion

        #region 正极左上右上缺角工艺
        /// <summary>
        /// 正极左上缺角开关-开发者
        /// </summary>
        public bool PLeftUpBevelSwitch_Developer;
        /// <summary>
        /// 正极左上缺角开关
        /// </summary>
        public bool PLeftUpBevelSwitch;
        /// <summary>
        /// 正极左上缺角面积最小值
        /// </summary>
        public double PLeftUpBevelAreaMin;
        /// <summary>
        /// 正极左上缺角面积最大值
        /// </summary>
        public double PLeftUpBevelAreaMax;
        /// <summary>
        /// 正极左上缺角灰度值最小值
        /// </summary>
        public int PLeftUpBevelGrayMin;
        /// <summary>
        /// 正极左上缺角框大小
        /// </summary>
        public double PLeftUpBevelFrame;
        /// <summary>
        /// 正极左上缺角命名自定义
        /// </summary>
        public string PLeftUpBevelName = "左上缺角";
        /// <summary>
        /// 正极左上缺角面积补偿值
        /// </summary>
        public double PLeftUpBevelCompensate;
        /// <summary>
        /// 正极左上缺角Row偏移
        /// </summary>
        public double PLeftUpBevelRowSkew;
        /// <summary>
        /// 正极左上缺角col偏移
        /// </summary>
        public double PLeftUpBevelColSkew;
        /// <summary>
        /// 正极左上缺角工艺范围
        /// </summary>
        public string PLeftUpBevelRange;


        /// <summary>
        /// 正极右上缺角开关-开发者
        /// </summary>
        public bool PRightUpBevelSwitch_Developer;
        /// <summary>
        /// 正极右上缺角开关
        /// </summary>
        public bool PRightUpBevelSwitch;
        /// <summary>
        /// 正极右上缺角面积最小值
        /// </summary>
        public double PRightUpBevelAreaMin;
        /// <summary>
        /// 正极右上缺角面积最大值
        /// </summary>
        public double PRightUpBevelAreaMax;
        /// <summary>
        /// 正极右上缺角灰度最小值
        /// </summary>
        public int PRightUpBevelGrayMin;
        /// <summary>
        /// 正极右上缺角框大小
        /// </summary>
        public double PRightUpBevelFrame;
        /// <summary>
        /// 正极右上缺角命名自定义
        /// </summary>
        public string PRightUpBevelName = "右上缺角";
        /// <summary>
        /// 正极右上缺角面积补偿值
        /// </summary>
        public double PRightUpBevelCompensate;
        /// <summary>
        /// 正极右上缺角Row偏移
        /// </summary>
        public double PRightUpBevelRowSkew;
        /// <summary>
        /// 正极右上缺角col偏移
        /// </summary>
        public double PRightUpBevelColSkew;
        /// <summary>
        /// 正极右上缺角工艺范围
        /// </summary>
        public string PRightUpBevelRange;
        #endregion

        #region 正极左下右下缺角工艺
        /// <summary>
        /// 正极左下缺角开关-开发者
        /// </summary>
        public bool PLeftDownBevelSwitch_Developer;
        /// <summary>
        /// 正极左下缺角开关
        /// </summary>
        public bool PLeftDownBevelSwitch;
        /// <summary>
        /// 正极左下缺角面积最小值
        /// </summary>
        public double PLeftDownBevelAreaMin;
        /// <summary>
        /// 正极左下缺角面积最大值
        /// </summary>
        public double PLeftDownBevelAreaMax;
        /// <summary>
        /// 正极左下缺角灰度最小值
        /// </summary>
        public int PLeftDownBevelGrayMin;
        /// <summary>
        /// 正极左下缺角框大小
        /// </summary>
        public double PLeftDownBevelFrame;
        /// <summary>
        /// 正极左下缺角命名自定义
        /// </summary>
        public string PLeftDownBevelName = "左下缺角";
        /// <summary>
        /// 正极左下缺角面积补偿值
        /// </summary>
        public double PLeftDownBevelCompensate;
        /// <summary>
        /// 正极左下缺角Row偏移
        /// </summary>
        public double PLeftDownBevelRowSkew;
        /// <summary>
        /// 正极左下缺角col偏移
        /// </summary>
        public double PLeftDownBevelColSkew;
        /// <summary>
        /// 正极左下缺角工艺范围
        /// </summary>
        public string PLeftDownBevelRange;


        /// <summary>
        /// 正极右下缺角开关-开发者
        /// </summary>
        public bool PRightDownBevelSwitch_Developer;
        /// <summary>
        /// 正极右下缺角开关
        /// </summary>
        public bool PRightDownBevelSwitch;
        /// <summary>
        /// 正极右下缺角面积最小值
        /// </summary>
        public double PRightDownBevelAreaMin;
        /// <summary>
        /// 正极右下缺角面积最大值
        /// </summary>
        public double PRightDownBevelAreaMax;
        /// <summary>
        /// 正极右下缺角灰度最小值
        /// </summary>
        public int PRightDownBevelGrayMin;
        /// <summary>
        /// 正极右下缺角框大小
        /// </summary>
        public double PRightDownBevelFrame;
        /// <summary>
        /// 正极右下缺角命名自定义
        /// </summary>
        public string PRightDownBevelName = "右下缺角";
        /// <summary>
        /// 正极右下缺角面积补偿值
        /// </summary>
        public double PRightDownBevelCompensate;
        /// <summary>
        /// 正极右下缺角Row偏移
        /// </summary>
        public double PRightDownBevelRowSkew;
        /// <summary>
        /// 正极右下缺角col偏移
        /// </summary>
        public double PRightDownBevelColSkew;
        /// <summary>
        /// 正极右下缺角工艺范围
        /// </summary>
        public string PRightDownBevelRange;
        #endregion

        #endregion

        #region 存储设置

        #region 保存图像


        /// <summary>
        /// 图片是否拼接
        /// </summary>
        public bool ImageIstitching;

        /// <summary>
        /// 图像加密保存
        /// </summary>
        public bool ImageEncryption;

        /// <summary>
        /// OK原始图开关
        /// </summary>
        public bool OriginalPictureSwitch;
        /// <summary>
        /// OK原始图存储路径
        /// </summary>
        public string PathO = "D:\\Ccd图像\\OK原图\\yyyy-MM-dd\\NorP";
        /// <summary>
        /// OK原始图命名规则
        /// </summary>
        public string NamingRuleO = "HH-mm-ss-fff-NorP;Line-Machine;ID";
        /// <summary>
        /// OK原始图保存天数
        /// </summary>
        public int DayO = 7;
        /// <summary>
        /// OK原始图存储格式
        /// </summary>
        public string ImangeFormatO;

        /// <summary>
        /// NG原始图开关
        /// </summary>
        public bool NGOriginalPictureSwitch;
        /// <summary>
        /// NG原始图存储路径
        /// </summary>
        public string PathNGO = "D:\\Ccd图像\\NG原图\\yyyy-MM-dd\\NorP";
        /// <summary>
        /// NG原始图命名规则
        /// </summary>
        public string NamingRuleNGO = "HH-mm-ss-fff-NorP;Line-Machine;ID";
        /// <summary>
        /// NG原始图保存天数
        /// </summary>
        public int DayNGO = 7;
        /// <summary>
        /// NG原始图存储格式
        /// </summary>
        public string ImangeFormatNGO;

        /// <summary>
        /// ok效果图开关
        /// </summary>
        public bool EffectPictureSwitch;
        /// <summary>
        /// ok效果图存储路径
        /// </summary>
        public string PathE = "D:\\Ccd图像\\良品图\\yyyy-MM-dd\\NorP";
        /// <summary>
        /// ok效果图命名规则
        /// </summary>
        public string NamingRuleE = "HH-mm-ss-fff-NorP;Line-Machine;ID";
        /// <summary>
        /// ok效果图保存天数
        /// </summary>
        public int DayE = 7;
        /// <summary>
        /// ok效果图存储格式
        /// </summary>
        public string ImangeFormatE;



        /// <summary>
        /// 不良效果图开关
        /// </summary>
        public bool NGPictureSwitch;
        /// <summary>
        /// 不良图存储路径
        /// </summary>
        public string PathNG = "D:\\Ccd图像\\不良图\\yyyy-MM-dd\\NorP";
        /// <summary>
        /// 不良图命名规则
        /// </summary>
        public string NamingRuleNG = "HH-mm-ss-fff-NorP;Line-Machine;ID";
        /// <summary>
        /// 不良图保存天数
        /// </summary>
        public int DayNG = 7;
        /// <summary>
        /// NG图存储格式
        /// </summary>
        public string ImangeFormatNG;

        /// <summary>
        /// MES图开关
        /// </summary>
        public bool MESPictureSwitch;
        /// <summary>
        /// MES图存储路径
        /// </summary>
        public string PathMES = "D:\\CcdNgImg_DCS\\yyyy-MM-dd\\NorP";
        /// <summary>
        /// MES图命名规则
        /// </summary>
        public string NamingRuleMES = "HH-mm-ss-fff-NorP;Line-Machine;ID";
        /// <summary>
        /// MES存储格式
        /// </summary>
        public string ImangeFormatMES;
        #endregion

        #region 数据存储
        ///// <summary>
        ///// 数据库路径
        ///// </summary>
        //public string DataBaseSava = "D:\\尺寸检测数据\\数据库文件";

        /// <summary>
        /// 生产数据路径
        /// </summary>
        public string SCDataSava = "D:\\尺寸检测数据\\生产数据\\yyyy-MM-dd-WSNorP";
        /// <summary>
        /// 生产数据保存天数
        /// </summary>
        public int SCDataSavaDay = 14;


        /// <summary>
        ///  MES数据保存开关
        /// </summary>
        public bool MESDataSwitch;
        /// <summary>
        ///  MES数据路径
        /// </summary>
        public string MESDataSava = "D:\\尺寸检测数据\\生产数据\\yyyy-MM-dd-WSNorP";
        /// <summary>
        ///  MES数据保存天数
        /// </summary>
        public int MESDataSavaDay = 14;

        /// <summary>
        /// 统计数据路径
        /// </summary>
        public string TJDataSava = "D:\\尺寸检测数据\\统计数据\\yyyy-MM";
        /// <summary>
        /// 统计数据保存天数
        /// </summary>
        public int TJDataSavaDay = 14;

        /// <summary>
        /// 片位数据路径
        /// </summary>
        public string PWDataSava = "D:\\尺寸检测数据\\片位数据\\yyyy-MM-dd";
        /// <summary>
        /// 片位数据保存天数
        /// </summary>
        public int PWDataSavaDay = 14;

        /// <summary>
        /// 生产表格命名
        /// </summary>
        public string SCName = "Line-MachineNorP";
        /// <summary>
        /// 统计表格命名
        /// </summary>
        public string TJName = "yyyy-MM Line-MachineNorP";
        /// <summary>
        /// 片位表格命名
        /// </summary>
        public string PWName = "yyyy-MM-dd Line-MachineNorP";
        /// <summary>
        /// MES表格命名
        /// </summary>
        public string MESName = "Line-MachineNorP";


        #endregion 

        /// <summary>
        /// 白班
        /// </summary>
        public string Morn = "08:00";
        /// <summary>
        /// 晚班
        /// </summary>
        public string Night = "20:00";
        /// <summary>
        /// log日志存储路径
        /// </summary>
        public string PathLog;
        #endregion

        #region 数据库设置
        /// <summary>
        ///数据库服务器地址
        /// </summary>
        public string MySqlServer = "localhost";

        /// <summary>
        ///数据库用户名
        /// </summary>
        public string MySqlUserId = "root";

        /// <summary>
        ///数据库密码
        /// </summary>
        public string MySqlPassword = "root";
        #endregion

        #region 系统设置

        /// <summary>
        /// 数据优先级开关
        /// </summary>
        public bool DataPrioritySwitch;

        /// <summary>
        /// 检测方式
        /// </summary>
        public string DetectMode = "8相机正负双测";
        /// <summary>
        /// 选择正极
        /// </summary>
        public bool PositiveSwitch = true;
        /// <summary>
        /// 选择负极
        /// </summary>
        public bool NegativeSwitch;

        /// <summary>
        /// 正极空片检测
        /// </summary>
        public bool NullSliceP = true;
        /// <summary>
        /// 负极空片检测
        /// </summary>
        public bool NullSliceN;
        /// <summary>
        /// 正极空片检测面积上限
        /// </summary>
        public double NullSlicePMax;
        /// <summary>
        /// 负极空片检测面积上限
        /// </summary>
        public double NullSliceNMax;

        /// <summary>
        /// OEE 数据发送，比如NG总数等等
        /// </summary>
        public bool OEEData;
        /// <summary>
        /// 刷卡登录开关
        /// </summary>
        public bool SwipingCardLogin;
        /// <summary>
        /// 刷卡登录开关开发者权限
        /// </summary>
        public bool SwipingCardLogin_Developer;
        /// <summary>
        /// 极耳双相机开关
        /// </summary>
        public bool JETwoCamera;




        /// <summary>
        /// 正极空片检测开发者权限
        /// </summary>
        public bool NullSliceP_Developer = true;
        /// <summary>
        /// 负极空片检测开发者权限
        /// </summary>
        public bool NullSliceN_Developer;

        /// <summary>
        /// 统计数据-分时统计
        /// </summary>
        public bool TJ_Hour;


        /// <summary>
        /// 负极卷径
        /// </summary>
        public string RollingDiameterN = "";
        /// <summary>
        /// 正极卷径
        /// </summary>
        public string RollingDiameterP = "";


        /// <summary>
        ///检测记录预警开关
        /// </summary>
        public bool EarlyWarning;

        /// <summary>
        ///负极左肩宽圆弧框大小
        /// </summary>
        public double NLeftArcSize;
        /// <summary>
        ///正极左肩宽圆弧框大小
        /// </summary>
        public double PLeftArcSize;
        /// <summary>
        ///负极左肩宽圆弧框横向偏移
        /// </summary>
        public double NLeftArcColSkew;
        /// <summary>
        ///正极左肩宽圆弧框横向偏移
        /// </summary>
        public double PLeftArcColSkew;
        /// <summary>
        ///负极左肩宽圆弧框竖向偏移
        /// </summary>
        public double NLeftArcRowSkew;
        /// <summary>
        ///正极左肩宽圆弧框s竖向偏移
        /// </summary>
        public double PLeftArcRowSkew;

        /// <summary>
        ///负极右肩宽圆弧框大小
        /// </summary>
        public double NRightArcSize;
        /// <summary>
        ///正极右肩宽圆弧框大小
        /// </summary>
        public double PRightArcSize;
        /// <summary>
        ///负极右肩宽圆弧框横向偏移
        /// </summary>
        public double NRightArcColSkew;
        /// <summary>
        ///正极右肩宽圆弧框横向偏移
        /// </summary>
        public double PRightArcColSkew;
        /// <summary>
        ///负极右肩宽圆弧框竖向偏移
        /// </summary>
        public double NRightArcRowSkew;
        /// <summary>
        ///正极右肩宽圆弧框s竖向偏移
        /// </summary>
        public double PRightArcRowSkew;



        /// <summary>
        /// 记录权限时间次数，达到指定次数后，退出权限（1次为1分钟）
        /// </summary>
        public int PowerTime = 0;
        /// <summary>
        /// 是否在主窗体上
        /// </summary>
        public bool FormMain = true;
        /// <summary>
        /// 主界面软件图标更换路径
        /// </summary>
        public string picFileName = null;
        /// <summary>
        /// 软件exe图标更换路径
        /// </summary>
        public string iconFileName = null;


        /// <summary>
        /// 负极辅助图路径
        /// </summary>
        public string NAuxiliaryChart = null;
        /// <summary>
        /// 正极辅助图路径
        /// </summary>
        public string PAuxiliaryChart = null;



        /// <summary>
        /// 开发者是否修改工艺
        /// </summary>
        public bool ChangeSet_Developer = false;
        /// <summary>
        /// 是否修改工艺
        /// </summary>
        public bool ChangeSet = false;


        /// <summary>
        /// 班次
        /// </summary>
        public string WorkingShift = "白班";

        #region 正负极选择相机的计算方式-是否单独计数与判断
        /// <summary>
        /// 负极头宽选择相机计算方式
        /// </summary>
        public string NJPHeadWidthType = "左下--右下";
        /// <summary>
        /// 负极尾宽选择相机计算方式
        /// </summary>
        public string NJPTailWidthType = "左上--右上";
        /// <summary>
        /// 负极头长选择相机计算方式
        /// </summary>
        public string NJPHeadLengthType = "左上--左下";
        /// <summary>
        /// 负极尾长选择相机计算方式
        /// </summary>
        public string NJPTailLengthType = "右上--右下";
        /// <summary>
        /// 负极总宽选择相机计算方式
        /// </summary>
        public string NJPTotalWidthType = "右上--右下";
        /// <summary>
        /// 负极涂布高选择相机计算方式
        /// </summary>
        public string NJPCoatingType = "右上--右下";
        /// <summary>
        /// 负极左肩宽计算方式
        /// </summary>
        public string NJELeftShoulderType = "极耳左竖边中点--极片左竖边中点";
        /// <summary>
        /// 负极右肩宽计算方式
        /// </summary>
        public string NJERightShoulderType = "极耳右竖边中点--极片右竖边中点";
        /// <summary>
        /// 负极极耳宽计算方式
        /// </summary>
        public string NJEWidthType = "极耳左竖边中点--极耳右竖边中点";



        /// <summary>
        /// 负极左上V宽度计算方式
        /// </summary>
        public string NLeftUpVWidthType = "";
        /// <summary>
        /// 负极右上V宽度计算方式
        /// </summary>
        public string NRightUpVWidthType = "";

        /// <summary>
        /// 负极左下V宽度计算方式
        /// </summary>
        public string NLeftDownVWidthType = "";
        /// <summary>
        /// 负极右下V宽度计算方式
        /// </summary>
        public string NRightDownVWidthType = "";







        /// <summary>
        /// 负极头尾宽是否同时计数
        /// </summary>
        public bool NJPWidthTogetherCount = false;
        /// <summary>
        /// 负极头尾宽是否同时判断
        /// </summary>
        public bool NJPWidthTogetherJudge = false;

        /// <summary>
        /// 负极头尾长是否同时判断
        /// </summary>
        public bool NJPLengthTogetherJudge = false;

        /// <summary>
        /// 负极肩宽是否同时计数
        /// </summary>
        public bool NJEShoulderTogetherCount = false;
        /// <summary>
        /// 负极肩宽是否同时判断
        /// </summary>
        public bool NJEShoulderTogetherJudge = false;


        /// <summary>
        /// 负极左上右上V角深度是否同时判断
        /// </summary>
        public bool NLURUVDepthTogetherJudge = false;

        /// <summary>
        /// 负极左下右下V角深度是否同时判断
        /// </summary>
        public bool NLDRDVDepthTogetherJudge = false;




        /// <summary>
        /// 正极头宽选择相机计算方式
        /// </summary>
        public string PJPHeadWidthType = "左下--右下";
        /// <summary>
        /// 正极尾宽选择相机计算方式
        /// </summary>
        public string PJPTailWidthType = "左上--右上";
        /// <summary>
        /// 正极头长选择相机计算方式
        /// </summary>
        public string PJPHeadLengthType = "右上--右下";
        /// <summary>
        /// 正极尾长选择相机计算方式
        /// </summary>
        public string PJPTailLengthType = "左上--左下";
        /// <summary>
        /// 正极总宽选择相机计算方式
        /// </summary>
        public string PJPTotalWidthType = "左上--左下";
        /// <summary>
        /// 正极涂布高选择相机计算方式
        /// </summary>
        public string PJPCoatingType = "左上--左下";
        /// <summary>
        /// 正极左肩宽计算方式
        /// </summary>
        public string PJELeftShoulderType = "极耳左竖边中点--极片竖边中点";
        /// <summary>
        /// 正极右肩宽计算方式
        /// </summary>
        public string PJERightShoulderType = "极耳右竖边中点--极片竖边中点";
        /// <summary>
        /// 正极极耳宽计算方式
        /// </summary>
        public string PJEWidthType = "极耳左竖边中点--极耳右竖边中点";
        /// <summary>
        /// 正极左上V宽度计算方式
        /// </summary>
        public string PLeftUpVWidthType = "";
        /// <summary>
        /// 正极右上V宽度计算方式
        /// </summary>
        public string PRightUpVWidthType = "";

        /// <summary>
        /// 正极左下V宽度计算方式
        /// </summary>
        public string PLeftDownVWidthType = "";
        /// <summary>
        /// 正极右下V宽度计算方式
        /// </summary>
        public string PRightDownVWidthType = "";




        /// <summary>
        /// 正极头尾宽是否同时计数
        /// </summary>
        public bool PJPWidthTogetherCount = false;
        /// <summary>
        /// 正极头尾宽是否同时判断
        /// </summary>
        public bool PJPWidthTogetherJudge = false;

        /// <summary>
        /// 正极头尾长是否同时判断
        /// </summary>
        public bool PJPLengthTogetherJudge = false;

        /// <summary>
        /// 正极肩宽是否同时计数
        /// </summary>
        public bool PJEShoulderTogetherCount = false;
        /// <summary>
        /// 正极肩宽是否同时判断
        /// </summary>
        public bool PJEShoulderTogetherJudge = false;

        /// <summary>
        /// 正极左上右上V角深度是否同时判断
        /// </summary>
        public bool PLURUVDepthTogetherJudge = false;

        /// <summary>
        /// 正极左下右下V角深度是否同时判断
        /// </summary>
        public bool PLDRDVDepthTogetherJudge = false;

        #endregion

        #region 负极取消判断

        /// <summary>
        /// 负极极片头宽是否取消判断
        /// </summary>
        public bool NJPHeadWidthCancelJudgment;
        /// <summary>
        /// 负极极片尾宽是否取消判断
        /// </summary>
        public bool NJPTailWidthCancelJudgment;
        /// <summary>
        /// 负极极片头长是否取消判断
        /// </summary>
        public bool NJPHeadLengthCancelJudgment;
        /// <summary>
        /// 负极极片尾长是否取消判断
        /// </summary>
        public bool NJPTailLengthCancelJudgment;
        /// <summary>
        /// 负极左肩宽是否取消判断
        /// </summary>
        public bool NJELeftShoulderCancelJudgment;
        /// <summary>
        /// 负极右肩宽是否取消判断
        /// </summary>
        public bool NJERightShoulderCancelJudgment;
        /// <summary>
        /// 负极极耳高是否取消判断
        /// </summary>
        public bool NJEHeightCancelJudgment;
        /// <summary>
        /// 负极极耳宽是否取消判断
        /// </summary>
        public bool NJEWidthCancelJudgment;
        /// <summary>
        /// 负极带料高是否取消判断
        /// </summary>
        public bool NDLHeightCancelJudgment;
        /// <summary>
        /// 负极总宽是否取消判断
        /// </summary>
        public bool NJPTotalWidthCancelJudgment;
        /// <summary>
        /// 负极涂布高是否取消判断
        /// </summary>
        public bool NJPCoatingCancelJudgment;
        /// <summary>
        /// 负极对角线是否取消判断
        /// </summary>
        public bool NDiagonalCancelJudgment;


        /// <summary>
        /// 负极相机左上角度否取消判断
        /// </summary>
        public bool NLeftUpAngleCancelJudgment;
        /// <summary>
        /// 负极右上相机角度否取消判断
        /// </summary>
        public bool NRightUpAngleCancelJudgment;
        /// <summary>
        /// 负极相机左下角度否取消判断
        /// </summary>
        public bool NLeftDownAngleCancelJudgment;
        /// <summary>
        /// 负极右下相机角度否取消判断
        /// </summary>
        public bool NRightDownAngleCancelJudgment;
        /// <summary>
        /// 负极左上V角深度是否取消判断
        /// </summary>
        public bool NLeftUpVDepthCancelJudgment;
        /// <summary>
        /// 负极右上V角深度是否取消判断
        /// </summary>
        public bool NRightUpVDepthCancelJudgment;
        /// <summary>
        /// 负极左下V角深度是否取消判断
        /// </summary>
        public bool NLeftDownVDepthCancelJudgment;
        /// <summary>
        /// 负极右下V角深度是否取消判断
        /// </summary>
        public bool NRightDownVDepthCancelJudgment;
        /// <summary>
        /// 负极左上V角宽度是否取消判断
        /// </summary>
        public bool NLeftUpVWidthCancelJudgment;
        /// <summary>
        /// 负极右上V角宽度是否取消判断
        /// </summary>
        public bool NRightUpVWidthCancelJudgment;
        /// <summary>
        /// 负极左下V角宽度是否取消判断
        /// </summary>
        public bool NLeftDownVWidthCancelJudgment;
        /// <summary>
        /// 负极右下V角宽度是否取消判断
        /// </summary>
        public bool NRightDownVWidthCancelJudgment;
        /// <summary>
        /// 负极左上V角角度是否取消判断
        /// </summary>
        public bool NLeftUpVAngleCancelJudgment;
        /// <summary>
        /// 负极右上V角角度是否取消判断
        /// </summary>
        public bool NRightUpVAngleCancelJudgment;
        /// <summary>
        /// 负极左下V角角度是否取消判断
        /// </summary>
        public bool NLeftDownVAngleCancelJudgment;
        /// <summary>
        /// 负极右下V角角度是否取消判断
        /// </summary>
        public bool NRightDownVAngleCancelJudgment;

        #endregion

        #region 正极取消判断
        /// <summary>
        /// 正极极片头宽是否取消判断
        /// </summary>
        public bool PJPHeadWidthCancelJudgment;
        /// <summary>
        /// 正极极片尾宽是否取消判断
        /// </summary>
        public bool PJPTailWidthCancelJudgment;
        /// <summary>
        /// 正极极片头长是否取消判断
        /// </summary>
        public bool PJPHeadLengthCancelJudgment;
        /// <summary>
        /// 正极极片尾长是否取消判断
        /// </summary>
        public bool PJPTailLengthCancelJudgment;
        /// <summary>
        /// 正极左肩宽是否取消判断
        /// </summary>
        public bool PJELeftShoulderCancelJudgment;
        /// <summary>
        /// 正极右肩宽是否取消判断
        /// </summary>
        public bool PJERightShoulderCancelJudgment;
        /// <summary>
        /// 正极极耳高是否取消判断
        /// </summary>
        public bool PJEHeightCancelJudgment;
        /// <summary>
        /// 正极极耳宽是否取消判断
        /// </summary>
        public bool PJEWidthCancelJudgment;
        /// <summary>
        /// 正极陶瓷高是否取消判断
        /// </summary>
        public bool PCeramicHeightCancelJudgment;
        /// <summary>
        /// 正极总宽是否取消判断
        /// </summary>
        public bool PJPTotalWidthCancelJudgment;
        /// <summary>
        /// 正极涂布高是否取消判断
        /// </summary>
        public bool PJPCoatingCancelJudgment;
        /// <summary>
        /// 正极对角线是否取消判断
        /// </summary>
        public bool PDiagonalCancelJudgment;

        /// <summary>
        /// 正极左上相机角度否取消判断
        /// </summary>
        public bool PLeftUpAngleCancelJudgment;
        /// <summary>
        /// 正极右上相机角度否取消判断
        /// </summary>
        public bool PRightUpAngleCancelJudgment;
        /// <summary>
        /// 正极左下相机角度否取消判断
        /// </summary>
        public bool PLeftDownAngleCancelJudgment;
        /// <summary>
        /// 正极右下相机角度否取消判断
        /// </summary>
        public bool PRightDownAngleCancelJudgment;

        /// <summary>
        /// 正极左上V角深度是否取消判断
        /// </summary>
        public bool PLeftUpVDepthCancelJudgment;
        /// <summary>
        /// 正极右上V角深度是否取消判断
        /// </summary>
        public bool PRightUpVDepthCancelJudgment;
        /// <summary>
        /// 正极左下V角深度是否取消判断
        /// </summary>
        public bool PLeftDownVDepthCancelJudgment;
        /// <summary>
        /// 正极右下V角深度是否取消判断
        /// </summary>
        public bool PRightDownVDepthCancelJudgment;

        /// <summary>
        /// 正极左上V角宽度是否取消判断
        /// </summary>
        public bool PLeftUpVWidthCancelJudgment;
        /// <summary>
        /// 正极右上V角宽度是否取消判断
        /// </summary>
        public bool PRightUpVWidthCancelJudgment;
        /// <summary>
        /// 正极左下V角宽度是否取消判断
        /// </summary>
        public bool PLeftDownVWidthCancelJudgment;
        /// <summary>
        /// 正极右下V角宽度是否取消判断
        /// </summary>
        public bool PRightDownVWidthCancelJudgment;

        /// <summary>
        /// 正极左上V角角度是否取消判断
        /// </summary>
        public bool PLeftUpVAngleCancelJudgment;
        /// <summary>
        /// 正极右上V角角度是否取消判断
        /// </summary>
        public bool PRightUpVAngleCancelJudgment;
        /// <summary>
        /// 正极左下V角角度是否取消判断
        /// </summary>
        public bool PLeftDownVAngleCancelJudgment;
        /// <summary>
        /// 正极右下V角角度是否取消判断
        /// </summary>
        public bool PRightDownVAngleCancelJudgment;

        #endregion

        #region 来料不良选项
        /// <summary>
        /// 负极头宽来料不良开关
        /// </summary>
        public bool NJPHeadWidth_LL;
        /// <summary>
        /// 负极尾宽来料不良开关
        /// </summary>
        public bool NJPTailWidth_LL;
        /// <summary>
        /// 负极头长来料不良开关
        /// </summary>
        public bool NJPHeadLength_LL;
        /// <summary>
        /// 负极尾长来料不良开关
        /// </summary>
        public bool NJPTailLength_LL;
        /// <summary>
        /// 负极极耳宽来料不良开关
        /// </summary>
        public bool NJEWidth_LL;
        /// <summary>
        /// 负极极耳高来料不良开关
        /// </summary>
        public bool NJEHeight_LL;
        /// <summary>
        /// 负极左肩宽来料不良开关
        /// </summary>
        public bool NJELeftShoulder_LL;
        /// <summary>
        /// 负极右肩宽来料不良开关
        /// </summary>
        public bool NJERightShoulder_LL;
        /// <summary>
        /// 负极涂布高来料不良开关
        /// </summary>
        public bool NJPCoating_LL;
        /// <summary>
        /// 负极总宽来料不良开关
        /// </summary>
        public bool NJPTotalWidth_LL;
        /// <summary>
        /// 负极带料高来料不良开关
        /// </summary>
        public bool NDLHeight_LL;






        /// <summary>
        /// 正极极头宽来料不良开关
        /// </summary>
        public bool PJPHeadWidth_LL;
        /// <summary>
        /// 正极极尾宽来料不良开关
        /// </summary>
        public bool PJPTailWidth_LL;
        /// <summary>
        /// 正极极头长来料不良开关
        /// </summary>
        public bool PJPHeadLength_LL;
        /// <summary>
        /// 正极极尾长来料不良开关
        /// </summary>
        public bool PJPTailLength_LL;
        /// <summary>
        /// 正极极耳宽来料不良开关
        /// </summary>
        public bool PJEWidth_LL;
        /// <summary>
        /// 正极极耳高来料不良开关
        /// </summary>
        public bool PJEHeight_LL;
        /// <summary>
        /// 正极左肩宽来料不良开关
        /// </summary>
        public bool PJELeftShoulder_LL;
        /// <summary>
        /// 正极右肩宽来料不良开关
        /// </summary>
        public bool PJERightShoulder_LL;
        /// <summary>
        /// 正极涂布高来料不良开关
        /// </summary>
        public bool PJPCoating_LL;
        /// <summary>
        /// 正极总宽来料不良开关
        /// </summary>
        public bool PJPTotalWidth_LL;
        /// <summary>
        /// 正极陶瓷高
        /// </summary>
        public bool PCeramicHeight_LL;

        #endregion

        #region     是否启用折线图 

        /// <summary>
        /// 负极极片头宽是否启用折线图
        /// </summary>
        public bool NJPHeadWidthChart;
        /// <summary>
        /// 负极极片尾宽是否启用折线图
        /// </summary>
        public bool NJPTailWidthChart;
        /// <summary>
        /// 负极左肩宽是否启用折线图
        /// </summary>
        public bool NJELeftShoulderChart;
        /// <summary>
        /// 负极右肩宽是否启用折线图
        /// </summary>
        public bool NJERightShoulderChart;


        /// <summary>
        /// 正极极片头宽是否启用折线图
        /// </summary>
        public bool PJPHeadWidthChart;
        /// <summary>
        /// 正极极片尾宽是否启用折线图
        /// </summary>
        public bool PJPTailWidthChart;
        /// <summary>
        /// 正极左肩宽是否启用折线图
        /// </summary>
        public bool PJELeftShoulderChart;
        /// <summary>
        /// 正极右肩宽是否启用折线图
        /// </summary>
        public bool PJERightShoulderChart;




        #endregion

        #region  肩宽是否启用圆弧

        /// <summary>
        /// 负极极片左肩宽是否启用圆弧
        /// </summary>
        public bool NJELeftShoulderArc;
        /// <summary>
        /// 负极极片右肩宽是否启用圆弧
        /// </summary>
        public bool NJERightShoulderArc;

        /// <summary>
        /// 正极极片左肩宽是否启用圆弧
        /// </summary>
        public bool PJELeftShoulderArc;
        /// <summary>
        /// 正极极片右肩宽是否启用圆弧
        /// </summary>
        public bool PJERightShoulderArc;
        #endregion 

        #endregion

        public MySet()
        {

        }
    }

}
